@hansjm10/volt-coding-agent 0.0.0-bootstrap.0 → 0.1.0

package/dist/core/remote/iroh/handshake.js

@@ -0,0 +1,621 @@
+import { Buffer } from "node:buffer";
+import { IROH_REMOTE_ALPN, IROH_REMOTE_CONVERSATION_STREAMS_FEATURE, IROH_REMOTE_HANDSHAKE_TYPE, IROH_REMOTE_HELLO_TYPE, IROH_REMOTE_MULTI_STREAMS_FEATURE, IrohRemoteOutcomeError, isIrohRemoteOutcome, isIrohRemoteRelayMode, isIrohRemoteRelayUrls, isIrohRemoteWorkingDirectory, isIrohRemoteWorktreeId, } from "./protocol.js";
+export const IROH_REMOTE_SESSION_ID_PATTERN = /^[a-z0-9_-]{1,128}$/;
+export class IrohRemoteHandshakeError extends Error {
+    outcome;
+    constructor(outcome, message) {
+        super(message);
+        this.name = "IrohRemoteHandshakeError";
+        this.outcome = outcome;
+    }
+}
+export function parseIrohRemoteHelloLine(line) {
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch (error) {
+        throw new IrohRemoteHandshakeError("invalid_conversation_target", `Failed to parse Iroh remote handshake: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return parseIrohRemoteHello(parsed);
+}
+export function parseIrohRemoteHandshakeResponseLine(line) {
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch (error) {
+        throw new Error(`Failed to parse Iroh remote handshake response: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return parseIrohRemoteHandshakeResponse(parsed);
+}
+export function parseIrohRemoteHello(value) {
+    const hello = expectRecord(value, "Iroh remote handshake");
+    if (hello.type !== IROH_REMOTE_HELLO_TYPE) {
+        throw new Error("unexpected handshake type");
+    }
+    if (hello.protocol !== IROH_REMOTE_ALPN) {
+        throw new Error(`unsupported protocol: ${typeof hello.protocol === "string" ? hello.protocol : "<missing>"}`);
+    }
+    const workspace = expectWorkspaceName(hello.workspace, "handshake workspace");
+    const mode = parseIrohRemoteHelloMode(hello);
+    return {
+        type: IROH_REMOTE_HELLO_TYPE,
+        protocol: IROH_REMOTE_ALPN,
+        workspace,
+        secret: expectOptionalString(hello.secret, "handshake secret"),
+        clientLabel: expectOptionalString(hello.clientLabel, "handshake clientLabel"),
+        clientNodeId: expectOptionalString(hello.clientNodeId, "handshake clientNodeId"),
+        ...mode,
+    };
+}
+export function parseIrohRemoteHandshakeResponse(value) {
+    const response = expectRecord(value, "Iroh remote handshake response");
+    if (response.type !== IROH_REMOTE_HANDSHAKE_TYPE) {
+        throw new Error("unexpected handshake response type");
+    }
+    if (response.success === true) {
+        const hostNodeId = expectOptionalString(response.hostNodeId, "handshake response hostNodeId");
+        const workspace = expectString(response.workspace, "handshake response workspace");
+        const features = parseOptionalFeatures(response.features);
+        const modeMetadata = parseOptionalHandshakeSuccessMode(response);
+        const remoteHost = parseOptionalRemoteHostHandshakeMetadata(response.remoteHost);
+        if (hasHandshakeSuccessModeMetadata(modeMetadata) && hostNodeId === undefined) {
+            throw new Error("handshake response hostNodeId is required for stream mode success");
+        }
+        assertRemoteHostMetadataMatchesHandshake(remoteHost, { hostNodeId, workspace });
+        const success = {
+            type: IROH_REMOTE_HANDSHAKE_TYPE,
+            success: true,
+            workspace,
+            clientNodeId: expectString(response.clientNodeId, "handshake response clientNodeId"),
+            ...(features === undefined ? {} : { features }),
+            ...modeMetadata,
+            ...(remoteHost === undefined ? {} : { remoteHost }),
+            child: expectOptionalString(response.child, "handshake response child"),
+        };
+        return hostNodeId === undefined ? success : { ...success, hostNodeId };
+    }
+    if (response.success === false) {
+        const outcome = expectOptionalOutcome(response.outcome, "handshake response outcome");
+        const hostNodeId = expectOptionalString(response.hostNodeId, "handshake response hostNodeId");
+        const workspace = expectOptionalString(response.workspace, "handshake response workspace");
+        const sessionId = expectOptionalRemoteSessionId(response.sessionId, "handshake response sessionId");
+        const retryAfterMs = expectOptionalNumber(response.retryAfterMs, "handshake response retryAfterMs");
+        const failure = {
+            type: IROH_REMOTE_HANDSHAKE_TYPE,
+            success: false,
+            error: expectString(response.error, "handshake response error"),
+        };
+        return {
+            ...failure,
+            ...(outcome === undefined ? {} : { outcome }),
+            ...(hostNodeId === undefined ? {} : { hostNodeId }),
+            ...(workspace === undefined ? {} : { workspace }),
+            ...(sessionId === undefined ? {} : { sessionId }),
+            ...(retryAfterMs === undefined ? {} : { retryAfterMs }),
+        };
+    }
+    throw new Error("handshake response success must be a boolean");
+}
+export function createIrohRemoteHandshakeSuccess(options) {
+    const response = {
+        type: IROH_REMOTE_HANDSHAKE_TYPE,
+        success: true,
+        workspace: options.workspace,
+        ...(options.hostNodeId === undefined ? {} : { hostNodeId: options.hostNodeId }),
+        clientNodeId: options.clientNodeId,
+        ...(options.features === undefined ? {} : { features: [...options.features] }),
+        ...(options.sessionId === undefined ? {} : { sessionId: options.sessionId }),
+        ...(options.conversation === undefined ? {} : { conversation: { ...options.conversation } }),
+        ...(options.workspaceDiscovery === undefined ? {} : { workspaceDiscovery: { ...options.workspaceDiscovery } }),
+        ...(options.workspaceManagement === undefined ? {} : { workspaceManagement: { ...options.workspaceManagement } }),
+        ...(options.remoteHost === undefined ? {} : { remoteHost: cloneRemoteHostHandshakeMetadata(options.remoteHost) }),
+        child: options.child,
+    };
+    return response;
+}
+export function createIrohRemoteHandshakeFailure(error, options = {}) {
+    return {
+        type: IROH_REMOTE_HANDSHAKE_TYPE,
+        success: false,
+        ...(options.outcome === undefined ? {} : { outcome: options.outcome }),
+        ...(options.hostNodeId === undefined ? {} : { hostNodeId: options.hostNodeId }),
+        ...(options.workspace === undefined ? {} : { workspace: options.workspace }),
+        ...(options.sessionId === undefined ? {} : { sessionId: options.sessionId }),
+        ...(options.retryAfterMs === undefined ? {} : { retryAfterMs: options.retryAfterMs }),
+        error,
+    };
+}
+export function assertIrohRemoteHandshakeHostIdentity(response, expectedHostNodeId) {
+    if (expectedHostNodeId === undefined) {
+        return;
+    }
+    const actualHostNodeId = response.hostNodeId;
+    if (actualHostNodeId !== expectedHostNodeId) {
+        throw new IrohRemoteOutcomeError("host_identity_mismatch", `expected ${expectedHostNodeId}, got ${actualHostNodeId ?? "<missing>"}`);
+    }
+}
+function cloneRemoteHostHandshakeMetadata(metadata) {
+    return {
+        workspace: metadata.workspace,
+        workspaceNames: [...metadata.workspaceNames],
+        workspaces: metadata.workspaces.map((workspace) => ({ ...workspace })),
+        features: [...metadata.features],
+        ...(metadata.hostNodeId === undefined ? {} : { hostNodeId: metadata.hostNodeId }),
+        ...(metadata.relayMode === undefined ? {} : { relayMode: metadata.relayMode }),
+        ...(metadata.relayUrls === undefined ? {} : { relayUrls: [...metadata.relayUrls] }),
+        ...(metadata.hostName === undefined ? {} : { hostName: metadata.hostName }),
+        ...(metadata.userName === undefined ? {} : { userName: metadata.userName }),
+        cwd: metadata.cwd,
+    };
+}
+function assertRemoteHostMetadataMatchesHandshake(metadata, response) {
+    if (metadata === undefined) {
+        return;
+    }
+    if (metadata.workspace !== response.workspace) {
+        throw new Error("handshake response remoteHost workspace must match top-level workspace");
+    }
+    if (metadata.hostNodeId !== undefined &&
+        response.hostNodeId !== undefined &&
+        metadata.hostNodeId !== response.hostNodeId) {
+        throw new Error("handshake response remoteHost hostNodeId must match top-level hostNodeId");
+    }
+}
+function expectRecord(value, label) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new Error(`${label} must be an object`);
+    }
+    return value;
+}
+function expectRecordForOutcome(value, label, outcome) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new IrohRemoteHandshakeError(outcome, `${label} must be an object`);
+    }
+    return value;
+}
+function expectString(value, label) {
+    if (typeof value !== "string" || value.length === 0) {
+        throw new Error(`${label} must be a non-empty string`);
+    }
+    return value;
+}
+function expectStringForOutcome(value, label, outcome) {
+    if (typeof value !== "string" || value.length === 0) {
+        throw new IrohRemoteHandshakeError(outcome, `${label} must be a non-empty string`);
+    }
+    return value;
+}
+function expectOptionalString(value, label) {
+    if (value === undefined) {
+        return undefined;
+    }
+    return expectString(value, label);
+}
+function expectOptionalNumber(value, label) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        throw new Error(`${label} must be a finite number`);
+    }
+    return value;
+}
+function expectWorkspaceName(value, label) {
+    const workspace = expectStringForOutcome(value, label, "invalid_workspace");
+    const validationError = getIrohRemoteWorkspaceNameValidationError(workspace, label);
+    if (validationError) {
+        throw new IrohRemoteHandshakeError("invalid_workspace", validationError);
+    }
+    return workspace;
+}
+export function isIrohRemoteWorkspaceName(value) {
+    return typeof value === "string" && getIrohRemoteWorkspaceNameValidationError(value, "workspace") === undefined;
+}
+function getIrohRemoteWorkspaceNameValidationError(value, label) {
+    if (value.length === 0) {
+        return `${label} must be a non-empty string`;
+    }
+    if (hasAsciiControlCharacter(value)) {
+        return `${label} must not contain ASCII control characters`;
+    }
+    if (Array.from(value).length > 255 || Buffer.byteLength(value, "utf8") > 1024) {
+        return `${label} exceeds maximum length`;
+    }
+    return undefined;
+}
+function hasAsciiControlCharacter(value) {
+    for (const char of value) {
+        const code = char.charCodeAt(0);
+        if (code <= 0x1f || code === 0x7f) {
+            return true;
+        }
+    }
+    return false;
+}
+export function isIrohRemoteSessionId(value) {
+    return typeof value === "string" && IROH_REMOTE_SESSION_ID_PATTERN.test(value);
+}
+function parseIrohRemoteHelloMode(hello) {
+    const modeKeys = ["conversation", "workspaceDiscovery", "workspaceManagement"].filter((key) => hello[key] !== undefined);
+    if (modeKeys.length !== 1) {
+        throw new IrohRemoteHandshakeError("invalid_conversation_target", "Iroh remote hello must include exactly one stream mode");
+    }
+    const modeKey = modeKeys[0];
+    if (modeKey === "conversation") {
+        return { mode: "conversation", conversation: parseConversationTarget(hello.conversation) };
+    }
+    if (modeKey === "workspaceDiscovery") {
+        return {
+            mode: "workspaceDiscovery",
+            workspaceDiscovery: parseWorkspaceDiscoveryTarget(hello.workspaceDiscovery),
+        };
+    }
+    return {
+        mode: "workspaceManagement",
+        workspaceManagement: parseWorkspaceManagementTarget(hello.workspaceManagement),
+    };
+}
+function parseConversationTarget(value) {
+    const target = expectRecordForOutcome(value, "handshake conversation", "invalid_conversation_target");
+    expectKnownFields(target, "handshake conversation", ["target", "sessionId", "worktreeId", "workingDirectory"]);
+    const targetKind = expectStringForOutcome(target.target, "handshake conversation target", "invalid_conversation_target");
+    // worktreeId is only accepted on target "new": resume targets derive the
+    // worktree from the persisted binding, never from the client.
+    if (targetKind !== "new" && target.worktreeId !== undefined) {
+        throw new IrohRemoteHandshakeError("invalid_conversation_target", `handshake conversation ${targetKind} target must not include worktreeId`);
+    }
+    if (targetKind !== "new" && target.workingDirectory !== undefined) {
+        throw new IrohRemoteHandshakeError("invalid_conversation_target", `handshake conversation ${targetKind} target must not include workingDirectory`);
+    }
+    if (targetKind === "last" || targetKind === "new") {
+        if (target.sessionId !== undefined) {
+            throw new IrohRemoteHandshakeError("invalid_conversation_target", `handshake conversation ${targetKind} target must not include sessionId`);
+        }
+        if (targetKind === "new") {
+            const worktreeId = target.worktreeId === undefined
+                ? undefined
+                : expectWorktreeId(target.worktreeId, "handshake conversation worktreeId");
+            const workingDirectory = target.workingDirectory === undefined
+                ? undefined
+                : expectWorkingDirectory(target.workingDirectory, "handshake conversation workingDirectory");
+            return {
+                target: "new",
+                ...(worktreeId === undefined ? {} : { worktreeId }),
+                ...(workingDirectory === undefined ? {} : { workingDirectory }),
+            };
+        }
+        return { target: targetKind };
+    }
+    if (targetKind === "session") {
+        return {
+            target: "session",
+            sessionId: expectRemoteSessionId(target.sessionId, "handshake conversation sessionId"),
+        };
+    }
+    throw new IrohRemoteHandshakeError("invalid_conversation_target", "unsupported conversation target");
+}
+function parseWorkspaceDiscoveryTarget(value) {
+    const target = expectRecordForOutcome(value, "handshake workspaceDiscovery", "invalid_conversation_target");
+    expectKnownFields(target, "handshake workspaceDiscovery", ["purpose"]);
+    const purpose = expectStringForOutcome(target.purpose, "handshake workspaceDiscovery purpose", "invalid_conversation_target");
+    if (purpose !== "list_sessions") {
+        throw new IrohRemoteHandshakeError("invalid_conversation_target", "unsupported workspaceDiscovery purpose");
+    }
+    return { purpose };
+}
+function parseWorkspaceManagementTarget(value) {
+    const target = expectRecordForOutcome(value, "handshake workspaceManagement", "invalid_conversation_target");
+    expectKnownFields(target, "handshake workspaceManagement", ["purpose"]);
+    const purpose = expectStringForOutcome(target.purpose, "handshake workspaceManagement purpose", "invalid_conversation_target");
+    if (purpose !== "unregister_workspace" && purpose !== "manage_worktrees") {
+        throw new IrohRemoteHandshakeError("invalid_conversation_target", "unsupported workspaceManagement purpose");
+    }
+    return { purpose };
+}
+function expectKnownFields(value, label, allowedFields) {
+    const allowed = new Set(allowedFields);
+    for (const field of Object.keys(value)) {
+        if (!allowed.has(field)) {
+            throw new IrohRemoteHandshakeError("invalid_conversation_target", `${label} has unexpected field ${field}`);
+        }
+    }
+}
+function expectKnownResponseFields(value, label, allowedFields) {
+    const allowed = new Set(allowedFields);
+    for (const field of Object.keys(value)) {
+        if (!allowed.has(field)) {
+            throw new Error(`${label} has unexpected field ${field}`);
+        }
+    }
+}
+function expectRemoteSessionId(value, label) {
+    const sessionId = expectStringForOutcome(value, label, "invalid_conversation_target");
+    if (!isIrohRemoteSessionId(sessionId)) {
+        throw new IrohRemoteHandshakeError("invalid_conversation_target", `${label} must match lowercase remote session ID syntax`);
+    }
+    return sessionId;
+}
+function expectWorktreeId(value, label) {
+    const worktreeId = expectStringForOutcome(value, label, "invalid_conversation_target");
+    if (!isIrohRemoteWorktreeId(worktreeId)) {
+        throw new IrohRemoteHandshakeError("invalid_conversation_target", `${label} must match lowercase worktree id syntax`);
+    }
+    return worktreeId;
+}
+function expectWorkingDirectory(value, label) {
+    const workingDirectory = expectStringForOutcome(value, label, "invalid_conversation_target");
+    if (!isIrohRemoteWorkingDirectory(workingDirectory)) {
+        throw new IrohRemoteHandshakeError("invalid_conversation_target", `${label} must be a relative POSIX path inside the workspace`);
+    }
+    return workingDirectory;
+}
+function expectOptionalRemoteSessionId(value, label) {
+    if (value === undefined) {
+        return undefined;
+    }
+    return expectRemoteSessionIdForResponse(value, label);
+}
+function expectOptionalOutcome(value, label) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!isIrohRemoteOutcome(value)) {
+        throw new Error(`${label} must be a known Iroh remote outcome`);
+    }
+    return value;
+}
+function parseOptionalFeatures(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const features = [];
+    for (const entry of value) {
+        if (typeof entry !== "string" || entry.length === 0) {
+            return [];
+        }
+        features.push(entry);
+    }
+    return features;
+}
+function parseRequiredFeatures(value, label) {
+    const features = parseOptionalFeatures(value);
+    if (features === undefined || features.length === 0) {
+        throw new Error(`${label} must be a non-empty string array`);
+    }
+    return features;
+}
+function parseOptionalRemoteHostHandshakeMetadata(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const metadata = expectRecord(value, "handshake response remoteHost");
+    expectKnownResponseFields(metadata, "handshake response remoteHost", [
+        "workspace",
+        "workspaceNames",
+        "workspaces",
+        "features",
+        "hostNodeId",
+        "relayMode",
+        "relayUrls",
+        "hostName",
+        "userName",
+        "cwd",
+    ]);
+    return {
+        workspace: expectWorkspaceNameForResponse(metadata.workspace, "handshake response remoteHost workspace"),
+        workspaceNames: parseRemoteHostWorkspaceNames(metadata.workspaceNames),
+        workspaces: parseRemoteHostWorkspaces(metadata.workspaces),
+        features: parseRequiredFeatures(metadata.features, "handshake response remoteHost features"),
+        ...(metadata.hostNodeId === undefined
+            ? {}
+            : { hostNodeId: expectString(metadata.hostNodeId, "handshake response remoteHost hostNodeId") }),
+        ...(metadata.relayMode === undefined
+            ? {}
+            : { relayMode: expectRelayMode(metadata.relayMode, "handshake response remoteHost relayMode") }),
+        ...(metadata.relayUrls === undefined
+            ? {}
+            : { relayUrls: expectRelayUrls(metadata.relayUrls, "handshake response remoteHost relayUrls") }),
+        ...(metadata.hostName === undefined
+            ? {}
+            : { hostName: expectString(metadata.hostName, "handshake response remoteHost hostName") }),
+        ...(metadata.userName === undefined
+            ? {}
+            : { userName: expectString(metadata.userName, "handshake response remoteHost userName") }),
+        cwd: expectString(metadata.cwd, "handshake response remoteHost cwd"),
+    };
+}
+function parseRemoteHostWorkspaceNames(value) {
+    if (!Array.isArray(value)) {
+        throw new Error("handshake response remoteHost workspaceNames must be an array");
+    }
+    return value.map((entry) => expectWorkspaceNameForResponse(entry, "handshake response remoteHost workspace name"));
+}
+function parseRemoteHostWorkspaces(value) {
+    if (!Array.isArray(value)) {
+        throw new Error("handshake response remoteHost workspaces must be an array");
+    }
+    return value.map((entry) => {
+        const workspace = expectRecord(entry, "handshake response remoteHost workspace");
+        expectKnownResponseFields(workspace, "handshake response remoteHost workspace", ["name", "status"]);
+        return {
+            name: expectWorkspaceNameForResponse(workspace.name, "handshake response remoteHost workspace name"),
+            status: expectWorkspaceStatus(workspace.status, "handshake response remoteHost workspace status"),
+        };
+    });
+}
+function expectWorkspaceNameForResponse(value, label) {
+    const workspace = expectString(value, label);
+    const validationError = getIrohRemoteWorkspaceNameValidationError(workspace, label);
+    if (validationError) {
+        throw new Error(validationError);
+    }
+    return workspace;
+}
+function expectWorkspaceStatus(value, label) {
+    const status = expectString(value, label);
+    if (status === "available" || status === "missing" || status === "unavailable") {
+        return status;
+    }
+    throw new Error(`${label} must be a supported workspace status`);
+}
+function expectRelayMode(value, label) {
+    if (isIrohRemoteRelayMode(value)) {
+        return value;
+    }
+    throw new Error(`${label} must be a supported relay mode`);
+}
+function expectRelayUrls(value, label) {
+    if (isIrohRemoteRelayUrls(value)) {
+        return [...value];
+    }
+    throw new Error(`${label} must be a non-empty array of relay URLs`);
+}
+function parseOptionalHandshakeSuccessMode(response) {
+    const modeKeys = ["conversation", "workspaceDiscovery", "workspaceManagement"].filter((key) => response[key] !== undefined);
+    if (modeKeys.length === 0) {
+        return {};
+    }
+    if (modeKeys.length !== 1) {
+        throw new Error("handshake response success must include exactly one stream mode");
+    }
+    assertRequiredHandshakeFeatures(parseOptionalFeatures(response.features));
+    const modeKey = modeKeys[0];
+    if (modeKey === "conversation") {
+        const sessionId = expectString(response.sessionId, "handshake response sessionId");
+        const conversation = parseConversationHandshakeMetadata(response.conversation);
+        if (conversation.sessionId !== sessionId) {
+            throw new Error("handshake response conversation sessionId must match top-level sessionId");
+        }
+        return { sessionId, conversation };
+    }
+    if (response.sessionId !== undefined) {
+        throw new Error(`handshake response ${modeKey} must not include sessionId`);
+    }
+    if (modeKey === "workspaceDiscovery") {
+        return { workspaceDiscovery: parseWorkspaceDiscoveryResponseMetadata(response.workspaceDiscovery) };
+    }
+    return { workspaceManagement: parseWorkspaceManagementResponseMetadata(response.workspaceManagement) };
+}
+function hasHandshakeSuccessModeMetadata(metadata) {
+    return (metadata.conversation !== undefined ||
+        metadata.workspaceDiscovery !== undefined ||
+        metadata.workspaceManagement !== undefined);
+}
+function assertRequiredHandshakeFeatures(features) {
+    if (features === undefined ||
+        !features.includes(IROH_REMOTE_MULTI_STREAMS_FEATURE) ||
+        !features.includes(IROH_REMOTE_CONVERSATION_STREAMS_FEATURE)) {
+        throw new Error("handshake response features must include required Iroh remote stream features");
+    }
+}
+function parseConversationHandshakeMetadata(value) {
+    const metadata = expectRecord(value, "handshake response conversation");
+    expectKnownResponseFields(metadata, "handshake response conversation", [
+        "target",
+        "sessionId",
+        "selection",
+        "requestedSessionId",
+        "worktreeId",
+        "workingDirectory",
+    ]);
+    const requestedSessionId = expectOptionalRemoteSessionId(metadata.requestedSessionId, "handshake response conversation requestedSessionId");
+    const worktreeId = expectOptionalWorktreeIdForResponse(metadata.worktreeId, "handshake response conversation worktreeId");
+    const workingDirectory = expectOptionalWorkingDirectoryForResponse(metadata.workingDirectory, "handshake response conversation workingDirectory");
+    const conversation = {
+        target: expectConversationTargetKind(metadata.target, "handshake response conversation target"),
+        sessionId: expectRemoteSessionIdForResponse(metadata.sessionId, "handshake response conversation sessionId"),
+        selection: expectConversationSelection(metadata.selection, "handshake response conversation selection"),
+        ...(requestedSessionId === undefined ? {} : { requestedSessionId }),
+        ...(worktreeId === undefined ? {} : { worktreeId }),
+        ...(workingDirectory === undefined ? {} : { workingDirectory }),
+    };
+    assertConversationTargetSelection(conversation);
+    return conversation;
+}
+function expectConversationTargetKind(value, label) {
+    const target = expectString(value, label);
+    if (target === "last" || target === "new" || target === "session") {
+        return target;
+    }
+    throw new Error(`${label} must be a supported conversation target`);
+}
+function expectConversationSelection(value, label) {
+    const selection = expectString(value, label);
+    if (selection === "resumed" ||
+        selection === "created" ||
+        selection === "created_missing_last" ||
+        selection === "session_rekeyed") {
+        return selection;
+    }
+    throw new Error(`${label} must be a supported conversation selection`);
+}
+function assertConversationTargetSelection(conversation) {
+    if (conversation.selection === "session_rekeyed") {
+        if (conversation.target !== "session") {
+            throw new Error("handshake response session_rekeyed selection requires session target");
+        }
+        if (conversation.requestedSessionId === undefined) {
+            throw new Error("handshake response session_rekeyed selection requires requestedSessionId");
+        }
+        if (conversation.requestedSessionId === conversation.sessionId) {
+            throw new Error("handshake response session_rekeyed selection requires a different sessionId");
+        }
+        return;
+    }
+    if (conversation.requestedSessionId !== undefined) {
+        throw new Error("handshake response requestedSessionId requires session_rekeyed selection");
+    }
+    if (conversation.target === "new" && conversation.selection !== "created") {
+        throw new Error("handshake response new target must use created selection");
+    }
+    if (conversation.target === "session" && conversation.selection !== "resumed") {
+        throw new Error("handshake response session target must use resumed selection");
+    }
+}
+function expectOptionalWorkingDirectoryForResponse(value, label) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!isIrohRemoteWorkingDirectory(value)) {
+        throw new Error(`${label} must be a relative POSIX path inside the workspace`);
+    }
+    return value;
+}
+function expectRemoteSessionIdForResponse(value, label) {
+    const sessionId = expectString(value, label);
+    if (!isIrohRemoteSessionId(sessionId)) {
+        throw new Error(`${label} must match lowercase remote session ID syntax`);
+    }
+    return sessionId;
+}
+function expectOptionalWorktreeIdForResponse(value, label) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!isIrohRemoteWorktreeId(value)) {
+        throw new Error(`${label} must match lowercase worktree id syntax`);
+    }
+    return value;
+}
+function parseWorkspaceDiscoveryResponseMetadata(value) {
+    const metadata = expectRecord(value, "handshake response workspaceDiscovery");
+    expectKnownResponseFields(metadata, "handshake response workspaceDiscovery", ["purpose"]);
+    if (metadata.purpose !== "list_sessions") {
+        throw new Error("handshake response workspaceDiscovery purpose must be list_sessions");
+    }
+    return { purpose: "list_sessions" };
+}
+function parseWorkspaceManagementResponseMetadata(value) {
+    const metadata = expectRecord(value, "handshake response workspaceManagement");
+    expectKnownResponseFields(metadata, "handshake response workspaceManagement", ["purpose"]);
+    if (metadata.purpose !== "unregister_workspace" && metadata.purpose !== "manage_worktrees") {
+        throw new Error("handshake response workspaceManagement purpose must be a supported management purpose");
+    }
+    return { purpose: metadata.purpose };
+}
+//# sourceMappingURL=handshake.js.map