mirror of
https://github.com/hanzoai/dev-desktop.git
synced 2026-11-20 01:07:23 +00:00
101 lines
3.9 KiB
TypeScript
101 lines
3.9 KiB
TypeScript
import { DeviceOperationError } from "@hanzodev/contracts";
|
|
import * as Digest from "effect/crypto/Digest";
|
|
import * as Duration from "effect/Duration";
|
|
import * as Effect from "effect/Effect";
|
|
import * as Hex from "effect/encoding/Hex";
|
|
import * as Schema from "effect/Schema";
|
|
import * as FileSystem from "effect/FileSystem";
|
|
import * as Path from "effect/Path";
|
|
import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/http";
|
|
|
|
import type { AgentDaemonEndpoint } from "./DeviceHost.ts";
|
|
|
|
const encodeEndpoint = Schema.encodeEffect(
|
|
Schema.fromJsonString(
|
|
Schema.Struct({
|
|
daemonBaseUrl: Schema.String,
|
|
daemonAuthToken: Schema.String,
|
|
stateDir: Schema.optionalKey(Schema.String),
|
|
}),
|
|
),
|
|
);
|
|
|
|
const key = Effect.fn("AgentDeviceTarget.key")(function* (value: string) {
|
|
const crypto = yield* Digest.Digest;
|
|
const digest = yield* crypto
|
|
.digest(Digest.sha256, new TextEncoder().encode(value))
|
|
.pipe(Effect.orDie);
|
|
return Hex.encode(digest).slice(0, 24);
|
|
});
|
|
|
|
/**
|
|
* A stable file per host lets forwarded endpoints change without retargeting
|
|
* other commands. Hosts with a daemon per device get a file per device.
|
|
*/
|
|
export const agentDeviceConfigPath = (
|
|
stateDir: string,
|
|
hostId: string,
|
|
path: Path.Path,
|
|
deviceId?: string,
|
|
) =>
|
|
key(deviceId === undefined ? hostId : JSON.stringify([hostId, deviceId])).pipe(
|
|
Effect.map((hash) => path.join(stateDir, "device", "hosts", `${hash}.json`)),
|
|
);
|
|
|
|
export const agentDeviceSession = (threadId: string, hostId: string, deviceId: string) =>
|
|
key(JSON.stringify([threadId, hostId, deviceId])).pipe(Effect.map((hash) => `hanzo-${hash}`));
|
|
|
|
export const writeAgentDeviceConfig = Effect.fn("AgentDeviceTarget.writeConfig")(function* (
|
|
file: string,
|
|
endpoint: AgentDaemonEndpoint & { readonly stateDir?: string | undefined },
|
|
) {
|
|
const fs = yield* FileSystem.FileSystem;
|
|
const path = yield* Path.Path;
|
|
yield* fs.makeDirectory(path.dirname(file), { recursive: true });
|
|
const content = yield* encodeEndpoint({
|
|
daemonBaseUrl: endpoint.baseUrl,
|
|
daemonAuthToken: endpoint.token,
|
|
...(endpoint.stateDir === undefined ? {} : { stateDir: endpoint.stateDir }),
|
|
});
|
|
if ((yield* fs.readFileString(file).pipe(Effect.orElseSucceed(() => ""))) === content) return;
|
|
const temporary = yield* fs.makeTempFile({ directory: path.dirname(file), prefix: ".endpoint-" });
|
|
yield* Effect.gen(function* () {
|
|
yield* fs.chmod(temporary, 0o600);
|
|
yield* fs.writeFileString(temporary, content);
|
|
yield* fs.rename(temporary, file);
|
|
}).pipe(Effect.ensuring(fs.remove(temporary, { force: true }).pipe(Effect.ignore)));
|
|
});
|
|
|
|
const AgentCloseResult = Schema.Union([
|
|
Schema.Struct({ result: Schema.Struct({ ok: Schema.Literal(true) }) }),
|
|
Schema.Struct({
|
|
error: Schema.Struct({
|
|
data: Schema.Struct({ code: Schema.Literal("SESSION_NOT_FOUND") }),
|
|
}),
|
|
}),
|
|
]);
|
|
|
|
/** Ends an agent-device session on a running daemon; an already-released session succeeds. */
|
|
export const releaseAgentDeviceSession =
|
|
(http: HttpClient.HttpClient, endpoint: AgentDaemonEndpoint) => (session: string) =>
|
|
HttpClientRequest.post(`${endpoint.baseUrl}/rpc`).pipe(
|
|
HttpClientRequest.bearerToken(endpoint.token),
|
|
HttpClientRequest.bodyJson({
|
|
jsonrpc: "2.0",
|
|
id: session,
|
|
method: "agent_device.command",
|
|
params: { command: "close", session, positionals: [], flags: {} },
|
|
}),
|
|
Effect.flatMap((request) => http.pipe(HttpClient.withScope).execute(request)),
|
|
// agent-device reports an already-released session as HTTP 404.
|
|
Effect.filterOrElse((response) => response.status === 404, HttpClientResponse.filterStatusOk),
|
|
Effect.flatMap(HttpClientResponse.schemaBodyJson(AgentCloseResult)),
|
|
Effect.scoped,
|
|
Effect.timeout(Duration.seconds(15)),
|
|
Effect.asVoid,
|
|
Effect.mapError(
|
|
(cause) =>
|
|
new DeviceOperationError({ operation: "close", reason: "request_failed", cause }),
|
|
),
|
|
);
|