@cydm/happy-elves 0.1.0-beta.31 → 0.1.0-beta.310

package/packages/client/dist/client.js

@@ -1,20 +1,47 @@
-import { decryptJson, encryptJson, normalizeSessionName, parseServerMessage, randomId, } from "../../shared/dist/index.js";
-import { addControllerDevice, claimControllerInvite, createControllerInvite, createPairingCode, createScopedToken, listDevices, listScopedTokens, revokeDevice, revokeScopedToken, tokenSelf, } from "./account.js";
+import { decryptJson, encryptJson, normalizeSessionTags, sessionTagKeys, sessionTagsMatch, normalizeSessionName, parseServerMessage, randomId, } from "../../shared/dist/index.js";
+import { addControllerDevice, claimControllerInvite, createControllerInvite, createPairingCode, createScopedToken, deleteMemory as deleteMemoryRecord, listDevices, listEncryptedMemories, listMemorySettings, renameDevice, markSessionRecent, pinWorkspaceCwd, listScopedTokens, revokeDevice, revokeScopedToken, saveEncryptedMemory, setSessionStar, setMemorySettings, setWorkspaceProjectPreference, tokenSelf, unpinWorkspaceCwd, workspaceSyncState, } from "./account.js";
 import { ControllerClientError, ControllerCommandError } from "./errors.js";
-import { authenticatedJson, normalizeRelayUrl, readRelayJson, relayHttpError } from "./http.js";
-import { parseSessionEventsResponse, } from "./parsers.js";
-import { sendAndWaitForDirectoryListing, sendAndWaitForFilePreview, sendAndWaitForHistoricalSessions, sendAndWaitForMachineDevExecResult, sendAndWaitForMachineDiagnostics, sendCommand, subscribe, } from "./transport.js";
+import { authenticatedJson, authenticatedJsonRaw, normalizeRelayUrl, readRelayJson, relayHttpError } from "./http.js";
+import { parseRepairSessionHeadResult, parseSessionEventsResponse, } from "./parsers.js";
+import { sendAndWaitForDirectoryListing, sendAndWaitForFilePreview, sendAndWaitForGatewayResult, sendAndWaitForHistoricalSessions, sendAndWaitForMachineDevExecResult, sendAndWaitForMachineDiagnostics, sendAndWaitForMemoryResult, sendAndWaitForScheduleResult, sendAndWaitForTurnReconcileResult, sendCommand, subscribe, } from "./transport.js";
 import { DEFAULT_SESSION_CREATE_WAIT_MS, } from "./types.js";
 import { isWaitCondition, matchesWaitCondition, parseEventCursor, parseEventLimit, parsePositiveDuration, requireNonEmpty, sleep, } from "./validation.js";
-const DEFAULT_RUN_SETTLEMENT_WAIT_MS = 15_000;
 const DEFAULT_BLOCKING_RUN_WAIT_MS = 30 * 60 * 1000;
+const RESUME_COMMAND_TIMEOUT_MS = 60_000;
+function addRuntimeSessionId(ids, value) {
+    if (typeof value === "string" && value.trim())
+        ids.add(value.trim());
+}
+function runtimeSessionIdsForMetadata(metadata) {
+    const ids = new Set();
+    addRuntimeSessionId(ids, metadata.importedFromRuntimeSessionId);
+    const runtime = metadata.runtime;
+    if (runtime && typeof runtime === "object" && !Array.isArray(runtime)) {
+        const record = runtime;
+        addRuntimeSessionId(ids, record.backendSessionId);
+        addRuntimeSessionId(ids, record.agentSessionId);
+        addRuntimeSessionId(ids, record.acpxRecordId);
+        const externalHandle = record.externalHandle;
+        if (externalHandle && typeof externalHandle === "object" && !Array.isArray(externalHandle)) {
+            addRuntimeSessionId(ids, externalHandle.sessionId);
+        }
+    }
+    return ids;
+}
+function isCanonicalRuntimeSessionCandidate(left, right) {
+    return left.createdAt < right.createdAt || (left.createdAt === right.createdAt && left.id < right.id);
+}
 function runSettlementTimeoutMs(options) {
     if (options.waitTimeoutMs !== undefined)
         return options.waitTimeoutMs;
-    if (options.runtimeTimeoutMs !== undefined)
-        return options.runtimeTimeoutMs + DEFAULT_RUN_SETTLEMENT_WAIT_MS;
     return DEFAULT_BLOCKING_RUN_WAIT_MS;
 }
+function memoryScore(memory, query, terms) {
+    const haystack = `${memory.title ?? ""}\n${memory.text}\n${memory.tags?.join(" ") ?? ""}`.toLowerCase();
+    const exact = haystack.includes(query.toLowerCase()) ? 10 : 0;
+    const termScore = terms.reduce((score, term) => score + (haystack.includes(term) ? 1 : 0), 0);
+    return exact + termScore;
+}
 export class ControllerClient {
     config;
     constructor(config) {
@@ -65,6 +92,76 @@ export class ControllerClient {
     async revokeDevice(deviceId) {
         return await revokeDevice(this.config, deviceId);
     }
+    async renameDevice(deviceId, name) {
+        return await renameDevice(this.config, deviceId, name);
+    }
+    async workspaceSync() {
+        return await workspaceSyncState(this.config);
+    }
+    async starSession(sessionId) {
+        return await setSessionStar(this.config, sessionId, true);
+    }
+    async unstarSession(sessionId) {
+        return await setSessionStar(this.config, sessionId, false);
+    }
+    async markSessionRecent(sessionId) {
+        return await markSessionRecent(this.config, sessionId);
+    }
+    async pinWorkspaceCwd(input) {
+        return await pinWorkspaceCwd(this.config, input);
+    }
+    async unpinWorkspaceCwd(input) {
+        return await unpinWorkspaceCwd(this.config, input);
+    }
+    async setWorkspaceProjectPreference(input) {
+        return await setWorkspaceProjectPreference(this.config, input);
+    }
+    async saveMemory(input) {
+        const id = input.id ?? randomId("mem");
+        const projectKey = requireNonEmpty(input.projectKey, "projectKey");
+        const text = requireNonEmpty(input.text, "text");
+        const payload = {
+            text,
+            ...(input.title ? { title: input.title } : {}),
+            ...(input.tags ? { tags: input.tags } : {}),
+        };
+        const saved = await saveEncryptedMemory(this.config, {
+            id,
+            projectKey,
+            encryptedMemory: await encryptJson(this.config.accountSecret, `memory:${projectKey}:${id}`, payload),
+        });
+        return await this.decodeMemory(saved);
+    }
+    async listMemories(projectKey) {
+        const { memories } = await listEncryptedMemories(this.config, projectKey);
+        const decoded = [];
+        for (const memory of memories) {
+            decoded.push(await this.decodeMemory(memory));
+        }
+        return decoded;
+    }
+    async searchMemories(input) {
+        const projectKey = requireNonEmpty(input.projectKey, "projectKey");
+        const query = requireNonEmpty(input.query, "query");
+        const settings = await this.memorySettings(projectKey);
+        if (settings[0]?.disabled === true)
+            return [];
+        const terms = query.toLowerCase().split(/\W+/).filter((term) => term.length >= 2);
+        const scored = (await this.listMemories(projectKey))
+            .map((memory) => ({ memory, score: memoryScore(memory, query, terms) }))
+            .filter((item) => item.score > 0)
+            .sort((left, right) => right.score - left.score || right.memory.updatedAt - left.memory.updatedAt);
+        return scored.slice(0, Math.max(1, input.limit ?? 5)).map((item) => item.memory);
+    }
+    async deleteMemory(id) {
+        return await deleteMemoryRecord(this.config, id);
+    }
+    async memorySettings(projectKey) {
+        return (await listMemorySettings(this.config, projectKey)).settings;
+    }
+    async setMemorySettings(input) {
+        return await setMemorySettings(this.config, input);
+    }
     async tokenSelf() {
         return await tokenSelf(this.config);
     }
@@ -90,6 +187,8 @@ export class ControllerClient {
                 continue;
             if (filter.name && (metadata.name ?? session.name) !== filter.name)
                 continue;
+            if (filter.tags && !sessionTagsMatch(metadata.tags, filter.tags))
+                continue;
             result.push(session);
         }
         return result;
@@ -108,7 +207,22 @@ export class ControllerClient {
         const agent = requireNonEmpty(input.agent, "agent");
         const name = requireNonEmpty(input.name, "name");
         const requestedRuntimeName = input.runtimeName === undefined ? undefined : normalizeSessionName(input.runtimeName);
+        const model = normalizeOptionalString(input.model);
+        const tags = normalizeSessionTags(input.tags);
         const requestId = randomId("req");
+        const metadata = {
+            agent,
+            cwd: input.cwd,
+            name,
+            ...(model ? { model } : {}),
+            ...(requestedRuntimeName ? { requestedRuntimeName } : {}),
+            createdFrom: input.createdFrom ?? "cli",
+            createRequestId: requestId,
+            permissionMode: input.permissionMode,
+            ...(tags.length > 0 ? { tags, tagKeys: sessionTagKeys(tags) } : {}),
+            ...(input.hiddenFromWorkspace ? { hiddenFromWorkspace: true } : {}),
+            ...(input.source ? { source: input.source } : {}),
+        };
         const result = await this.sendCommand({
             type: "controller:createSession",
             requestId,
@@ -116,23 +230,71 @@ export class ControllerClient {
             agent,
             cwd: input.cwd,
             name,
-            encryptedMetadata: await encryptJson(this.config.accountSecret, `session:create:${requestId}`, {
-                agent,
-                cwd: input.cwd,
-                name,
-                ...(requestedRuntimeName ? { requestedRuntimeName } : {}),
-                createdFrom: input.createdFrom ?? "cli",
-                createRequestId: requestId,
-                permissionMode: input.permissionMode,
-            }),
+            ...(model ? { model } : {}),
+            encryptedMetadata: await encryptJson(this.config.accountSecret, `session:create:${requestId}`, metadata),
         });
-        if (result.sessionId) {
-            const session = await this.waitForCreatedSession(result.sessionId, requestId, "Session creation failed", "SESSION_CREATE_FAILED", "Machine disconnected before session became ready");
-            if (requestedRuntimeName && session.name !== requestedRuntimeName) {
-                await this.recoverCreatedSessionName(result.sessionId, requestId, requestedRuntimeName, session.name);
+        return { ...result, requestId };
+    }
+    async updateSessionMetadata(sessionId, metadata) {
+        const checkedSessionId = requireNonEmpty(sessionId, "sessionId");
+        const encryptedMetadata = await encryptJson(this.config.accountSecret, `session:${checkedSessionId}:metadata:${Date.now()}`, metadata);
+        const response = await authenticatedJsonRaw(this.config, `/api/sessions/${encodeURIComponent(checkedSessionId)}/metadata`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ encryptedMetadata }),
+        });
+        if (!response || typeof response !== "object" || !("session" in response)) {
+            throw new ControllerClientError("Session metadata response is invalid", "RELAY_RESPONSE_INVALID");
+        }
+        const session = response.session;
+        const message = parseServerMessage({ type: "server:session", session });
+        if (message.type !== "server:session") {
+            throw new ControllerClientError("Session metadata response is invalid", "RELAY_RESPONSE_INVALID");
+        }
+        return message.session;
+    }
+    async setSessionTags(sessionId, tags) {
+        const checkedSessionId = requireNonEmpty(sessionId, "sessionId");
+        const session = await this.getSession(checkedSessionId);
+        if (!session)
+            throw new ControllerClientError(`Session not found: ${checkedSessionId}`, "SESSION_NOT_FOUND");
+        const normalized = normalizeSessionTags(tags);
+        const metadata = await this.decodeSessionMetadata(session);
+        const nextMetadata = {
+            ...metadata,
+            tags: normalized,
+            tagKeys: sessionTagKeys(normalized),
+        };
+        if (normalized.length === 0) {
+            delete nextMetadata.tags;
+            delete nextMetadata.tagKeys;
+        }
+        const updated = await this.updateSessionMetadata(checkedSessionId, nextMetadata);
+        return { session: updated, tags: normalized };
+    }
+    async findLoadedRuntimeSession(input) {
+        const machineId = requireNonEmpty(input.machineId, "machineId");
+        const agent = requireNonEmpty(input.agent, "agent");
+        const runtimeSessionId = requireNonEmpty(input.runtimeSessionId, "runtimeSessionId");
+        let selected;
+        let closed;
+        for (const session of (await this.snapshot()).sessions) {
+            if (session.machineId !== machineId || session.agent !== agent)
+                continue;
+            const metadata = await this.decodeSessionMetadata(session);
+            if (!runtimeSessionIdsForMetadata(metadata).has(runtimeSessionId))
+                continue;
+            if (session.status === "closed") {
+                closed ??= session;
+                continue;
             }
+            if (!selected || isCanonicalRuntimeSessionCandidate(session, selected))
+                selected = session;
         }
-        return { ...result, requestId };
+        if (!selected && closed) {
+            throw new ControllerClientError("This runtime session is archived in Happy Elves. Restore the archived session before importing it again.", "RUNTIME_SESSION_ARCHIVED", { sessionId: closed.id });
+        }
+        return selected;
     }
     async collect(sessionId, input = {}) {
         return (await this.collectPage(sessionId, input)).events;
@@ -161,6 +323,29 @@ export class ControllerClient {
             ...(page.oldestEventId === undefined ? {} : { oldestEventId: page.oldestEventId }),
         };
     }
+    async repairSessionHead(sessionId, input) {
+        const checkedSessionId = requireNonEmpty(sessionId, "sessionId");
+        const currentHead = requireNonEmpty(input.currentHead, "currentHead");
+        const lastTurnId = requireNonEmpty(input.lastTurnId, "lastTurnId");
+        const status = input.status;
+        const turnId = requireNonEmpty(input.basis.turnId, "basis.turnId");
+        const eventMessageId = requireNonEmpty(input.basis.eventMessageId, "basis.eventMessageId");
+        return await authenticatedJson(this.config, `/api/sessions/${encodeURIComponent(checkedSessionId)}/head`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+                currentHead,
+                lastTurnId,
+                ...(status ? { status } : {}),
+                basis: {
+                    turnId,
+                    eventMessageId,
+                    turnSeq: input.basis.turnSeq,
+                    ...(input.basis.occurredAt === undefined ? {} : { occurredAt: input.basis.occurredAt }),
+                },
+            }),
+        }, parseRepairSessionHeadResult);
+    }
     async wait(sessionId, input = {}) {
         const checkedSessionId = requireNonEmpty(sessionId, "sessionId");
         const until = input.until ?? "idle";
@@ -182,10 +367,15 @@ export class ControllerClient {
             await sleep(intervalMs);
         }
     }
-    async resume(sessionId) {
+    async resume(sessionId, options = {}) {
         const checkedSessionId = requireNonEmpty(sessionId, "sessionId");
         const requestId = randomId("req");
-        return await this.sendCommand({ type: "controller:resume", requestId, sessionId: checkedSessionId });
+        return await this.sendCommand({
+            type: "controller:resume",
+            requestId,
+            sessionId: checkedSessionId,
+            ...(options.syncDirection ? { syncDirection: options.syncDirection } : {}),
+        }, false, RESUME_COMMAND_TIMEOUT_MS);
     }
     async listHistoricalSessionsPage(input) {
         const machineId = requireNonEmpty(input.machineId, "machineId");
@@ -269,11 +459,69 @@ export class ControllerClient {
         }, input.waitTimeoutMs);
         return message.result;
     }
+    async gateway(input) {
+        const machineId = requireNonEmpty(input.machineId, "machineId");
+        const requestId = randomId("req");
+        const channel = input.channel ? { ...input.channel } : undefined;
+        if (channel?.appSecret) {
+            channel.encryptedAppSecret = await encryptJson(this.config.accountSecret, `gateway:secret:${requestId}:${channel.id ?? channel.type}`, {
+                appSecret: channel.appSecret,
+            });
+            delete channel.appSecret;
+        }
+        const message = await sendAndWaitForGatewayResult(this.config, {
+            type: "controller:gateway",
+            requestId,
+            machineId,
+            action: input.action,
+            channelId: input.channelId,
+            channel,
+            externalConversationId: input.externalConversationId,
+            externalMessageId: input.externalMessageId,
+            text: input.text,
+        });
+        return message.result;
+    }
+    async schedule(input) {
+        const machineId = requireNonEmpty(input.machineId, "machineId");
+        const requestId = randomId("req");
+        const message = await sendAndWaitForScheduleResult(this.config, {
+            type: "controller:schedule",
+            requestId,
+            machineId,
+            action: input.action,
+            scheduleId: input.scheduleId,
+            occurrenceId: input.occurrenceId,
+            schedule: input.schedule,
+        });
+        return message.result;
+    }
+    async memory(input) {
+        const machineId = requireNonEmpty(input.machineId, "machineId");
+        const requestId = randomId("req");
+        const message = await sendAndWaitForMemoryResult(this.config, {
+            type: "controller:memory",
+            requestId,
+            machineId,
+            action: input.action,
+            projectKey: input.projectKey,
+            path: input.path,
+            query: input.query,
+            limit: input.limit,
+            mode: input.mode,
+            write: input.write,
+            promote: input.promote,
+        });
+        return message.result;
+    }
     async importHistoricalSession(input) {
         const machineId = requireNonEmpty(input.machineId, "machineId");
         const agent = requireNonEmpty(input.agent, "agent");
         const runtimeSessionId = requireNonEmpty(input.runtimeSessionId, "runtimeSessionId");
         const name = requireNonEmpty(input.name, "name");
+        const existing = await this.findLoadedRuntimeSession({ machineId, agent, runtimeSessionId });
+        if (existing)
+            return { sessionId: existing.id, mode: "existing", events: [] };
         const requestId = randomId("req");
         const result = await this.sendCommand({
             type: "controller:importHistoricalSession",
@@ -286,6 +534,7 @@ export class ControllerClient {
             encryptedMetadata: await encryptJson(this.config.accountSecret, `session:import:${requestId}`, {
                 agent,
                 cwd: input.cwd,
+                importRequestId: requestId,
                 name,
                 ...(input.providerName ? { providerName: input.providerName } : {}),
                 importedFromRuntimeSessionId: runtimeSessionId,
@@ -308,6 +557,7 @@ export class ControllerClient {
         const checkedSessionId = requireNonEmpty(sessionId, "sessionId");
         const from = requireNonEmpty(input.from, "from");
         const name = requireNonEmpty(input.name, "name");
+        const tags = normalizeSessionTags(input.tags);
         const requestId = randomId("req");
         return await this.sendCommand({
             type: "controller:fork",
@@ -319,6 +569,7 @@ export class ControllerClient {
                 sourceSessionId: checkedSessionId,
                 from,
                 name,
+                ...(tags.length > 0 ? { tags, tagKeys: sessionTagKeys(tags) } : {}),
             }),
         });
     }
@@ -344,19 +595,28 @@ export class ControllerClient {
         const promptText = requireNonEmpty(text, "text");
         const requestId = randomId("req");
         const turnId = randomId("turn");
-        const wait = options.wait ?? true;
+        const wait = options.wait ?? false;
         const timeoutMs = wait ? options.waitTimeoutMs : options.ackTimeoutMs;
+        const model = normalizeOptionalString(options.model);
         const result = await this.sendCommand({
             type: "controller:prompt",
             requestId,
             sessionId: checkedSessionId,
             turnId,
+            ...(model ? { model } : {}),
             encryptedPrompt: await encryptJson(this.config.accountSecret, `prompt:${checkedSessionId}:${turnId}`, {
                 type: "user_prompt",
                 text: promptText,
             }),
             permissionMode: options.permissionMode ?? "approve-reads",
-            timeoutMs: options.runtimeTimeoutMs,
+            encryptedMemoryOptions: options.memoryMode && options.memoryProjectKey
+                ? await encryptJson(this.config.accountSecret, `prompt:${checkedSessionId}:${turnId}:memory`, {
+                    mode: options.memoryMode,
+                    projectKey: options.memoryProjectKey,
+                    ...(options.memoryTopN ? { topN: options.memoryTopN } : {}),
+                })
+                : undefined,
+            timeoutMs: options.inactivityTimeoutMs ?? options.runtimeTimeoutMs,
         }, wait, timeoutMs);
         if (wait) {
             await this.waitForRunSettlement(checkedSessionId, turnId, runSettlementTimeoutMs(options));
@@ -364,6 +624,17 @@ export class ControllerClient {
         }
         return { ...result, requestId, turnId };
     }
+    async reconcileTurn(sessionId, turnId) {
+        const checkedSessionId = requireNonEmpty(sessionId, "sessionId");
+        const requestId = randomId("req");
+        const response = await sendAndWaitForTurnReconcileResult(this.config, {
+            type: "controller:reconcileTurn",
+            requestId,
+            sessionId: checkedSessionId,
+            ...(turnId ? { turnId: requireNonEmpty(turnId, "turnId") } : {}),
+        });
+        return { ...response.result, machineId: response.machineId, requestId: response.result.requestId ?? requestId };
+    }
     async cancel(sessionId, input = {}) {
         const checkedSessionId = requireNonEmpty(sessionId, "sessionId");
         const turnId = input.turnId === undefined ? undefined : requireNonEmpty(input.turnId, "turnId");
@@ -423,6 +694,18 @@ export class ControllerClient {
             return {};
         }
     }
+    async decodeMemory(memory) {
+        const payload = await decryptJson(this.config.accountSecret, memory.encryptedMemory);
+        return {
+            id: memory.id,
+            projectKey: memory.projectKey,
+            ...(payload.title ? { title: payload.title } : {}),
+            text: typeof payload.text === "string" ? payload.text : JSON.stringify(payload),
+            ...(Array.isArray(payload.tags) ? { tags: payload.tags.filter((tag) => typeof tag === "string") } : {}),
+            createdAt: memory.createdAt,
+            updatedAt: memory.updatedAt,
+        };
+    }
     async sendCommand(command, waitForDone = false, timeoutMs) {
         return await sendCommand({
             config: this.config,
@@ -440,38 +723,6 @@ export class ControllerClient {
         }
         return session;
     }
-    async recoverCreatedSessionName(sessionId, createRequestId, expectedName, observedName) {
-        try {
-            await this.renameSession(sessionId, expectedName);
-            const renamed = await this.waitForSessionName(sessionId, expectedName, 5_000);
-            if (renamed?.name === expectedName)
-                return;
-            throw new Error(`expected "${expectedName}", got "${renamed?.name ?? observedName}"`);
-        }
-        catch (error) {
-            const detail = error instanceof Error ? error.message : String(error);
-            let cleanupDetail = "";
-            try {
-                await this.close(sessionId, "runtime name was not confirmed after create");
-                cleanupDetail = " The created session was closed to avoid a half-named worker.";
-            }
-            catch (cleanupError) {
-                cleanupDetail = ` Cleanup close also failed: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}.`;
-            }
-            throw new ControllerCommandError(`Session runtime name was not confirmed after create: expected "${expectedName}", got "${observedName}". Rename recovery failed: ${detail}.${cleanupDetail}`, "SESSION_RENAME_FAILED", undefined, createRequestId);
-        }
-    }
-    async waitForSessionName(sessionId, expectedName, timeoutMs) {
-        const startedAt = Date.now();
-        let latest;
-        while (Date.now() - startedAt <= timeoutMs) {
-            latest = await this.getSession(sessionId);
-            if (latest?.name === expectedName)
-                return latest;
-            await sleep(150);
-        }
-        return latest;
-    }
     async waitForRunSettlement(sessionId, turnId, timeoutMs) {
         const startedAt = Date.now();
         while (true) {
@@ -510,4 +761,7 @@ export class ControllerClient {
         return await authenticatedJson(this.config, `/api/sessions/${encodeURIComponent(sessionId)}/events${suffix}`, { method: "GET" }, parseSessionEventsResponse);
     }
 }
+function normalizeOptionalString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
 //# sourceMappingURL=client.js.map

package/packages/client/dist/index.d.ts

@@ -1,4 +1,4 @@
 export { ControllerClient } from "./client.js";
 export { ControllerClientError, ControllerCommandError } from "./errors.js";
-export type { AddControllerDeviceInput, AddControllerDeviceResult, CancelInput, CollectInput, CommandResult, ControllerClientConfig, ControllerDevice, ControllerInviteClaimInput, ControllerInviteClaimResult, ControllerInviteCreateInput, ControllerInviteCreateResult, ControllerSnapshot, ControllerSubscriptionHandlers, CreateScopedTokenInput, CreateSessionInput, DecodedSessionEvent, DecodedSessionEventsPage, DeviceListResponse, DirectoryInput, DirectoryListResponse, FilePreviewInput, FilePreviewResponse, EventCursor, ForkInput, HistoricalSessionListPage, HistoricalSessionListResponse, HistoricalSessionsInput, ImportHistoricalSessionInput, MachineListResponse, MachineMetadata, PermissionMode, RunOptions, ScopedTokenInfo, ScopedTokenScope, ScopedTokenSelf, SessionFilter, SessionMetadata, WaitCondition, WaitInput, } from "./types.js";
+export type { AddControllerDeviceInput, AddControllerDeviceResult, CancelInput, CollectInput, CommandResult, ControllerClientConfig, ControllerDevice, ControllerInviteClaimInput, ControllerInviteClaimResult, ControllerInviteCreateInput, ControllerInviteCreateResult, ControllerSnapshot, ControllerSubscriptionHandlers, CreateScopedTokenInput, CreateSessionInput, DecodedSessionEvent, DecodedSessionEventsPage, DeviceListResponse, DirectoryInput, DirectoryListResponse, FilePreviewInput, FilePreviewResponse, EventCursor, ForkInput, HistoricalSessionListPage, HistoricalSessionListResponse, HistoricalSessionsInput, ImportHistoricalSessionInput, MachineListResponse, MachineMetadata, DecodedMemoryRecord, EncryptedMemoryRecord, MemoryPayload, MemoryCommandInput, MemoryCommandResponse, MemorySaveInput, MemorySearchInput, MemorySettings, PermissionMode, RepairSessionHeadInput, RepairSessionHeadResult, RunOptions, ScopedTokenInfo, ScopedTokenScope, ScopedTokenSelf, SessionFilter, SessionMetadata, WaitCondition, WaitInput, WorkspaceCwdPin, WorkspaceCwdPinInput, WorkspaceProjectPreference, WorkspaceProjectPreferenceInput, WorkspaceRecentSession, WorkspaceSessionStar, WorkspaceSessionStarResult, WorkspaceSyncState, } from "./types.js";
 //# sourceMappingURL=index.d.ts.map

package/packages/client/dist/parsers.d.ts

@@ -1,5 +1,5 @@
-import { type PairingStartResponse } from "@happy-elves/shared";
-import type { AddControllerDeviceResult, ControllerInviteClaimResult, ControllerInviteCreateResult, DeviceListResponse, ScopedTokenInfo, ScopedTokenSelf, SessionEventsResponse } from "./types.js";
+import { type PairingStartResponse } from "../../shared/dist/index.js";
+import type { AddControllerDeviceResult, ControllerInviteClaimResult, ControllerInviteCreateResult, DeviceListResponse, EncryptedMemoryRecord, MemorySettings, RenameDeviceResult, ScopedTokenInfo, ScopedTokenSelf, RepairSessionHeadResult, SessionEventsResponse, WorkspaceCwdPin, WorkspaceProjectPreference, WorkspaceRecentSession, WorkspaceSessionStarResult, WorkspaceSyncState } from "./types.js";
 export declare function parsePairingStartResponse(value: unknown): PairingStartResponse;
 export declare function parseDevicesResponse(value: unknown): DeviceListResponse;
 export declare function parseAddControllerDeviceResult(value: unknown): AddControllerDeviceResult;
@@ -9,6 +9,31 @@ export declare function parseRevokeDeviceResult(value: unknown): {
     deviceId: string;
     revokedAt: number;
 };
+export declare function parseRenameDeviceResult(value: unknown): RenameDeviceResult;
+export declare function parseWorkspaceSyncState(value: unknown): WorkspaceSyncState;
+export declare function parseWorkspaceSessionStarResult(value: unknown): WorkspaceSessionStarResult;
+export declare function parseWorkspaceRecentSessionResult(value: unknown): WorkspaceRecentSession;
+export declare function parseWorkspaceCwdPinResult(value: unknown): WorkspaceCwdPin;
+export declare function parseWorkspaceCwdUnpinResult(value: unknown): {
+    machineId: string;
+    cwd: string;
+    removed: boolean;
+    removedAt: number;
+};
+export declare function parseWorkspaceProjectPreferenceResult(value: unknown): WorkspaceProjectPreference;
+export declare function parseMemoryListResponse(value: unknown): {
+    memories: EncryptedMemoryRecord[];
+};
+export declare function parseMemorySaveResult(value: unknown): EncryptedMemoryRecord;
+export declare function parseMemoryDeleteResult(value: unknown): {
+    id: string;
+    deleted: boolean;
+    deletedAt: number;
+};
+export declare function parseMemorySettingsList(value: unknown): {
+    settings: MemorySettings[];
+};
+export declare function parseMemorySettingsResult(value: unknown): MemorySettings;
 export declare function parseScopedTokenSelf(value: unknown): ScopedTokenSelf;
 export declare function parseScopedTokenCreate(value: unknown): {
     token: string;
@@ -22,4 +47,5 @@ export declare function parseScopedTokenRevoke(value: unknown): {
     revokedAt: number;
 };
 export declare function parseSessionEventsResponse(value: unknown): SessionEventsResponse;
+export declare function parseRepairSessionHeadResult(value: unknown): RepairSessionHeadResult;
 //# sourceMappingURL=parsers.d.ts.map