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

package/apps/relay/dist/http-schemas.d.ts

@@ -25,6 +25,10 @@ export declare const pairingClaimSchema: z.ZodObject<{
 export declare const deviceRevokeSchema: z.ZodObject<{
     deviceId: z.ZodString;
 }, z.core.$strip>;
+export declare const deviceRenameSchema: z.ZodObject<{
+    deviceId: z.ZodString;
+    name: z.ZodString;
+}, z.core.$strip>;
 export declare const scopedTokenCreateSchema: z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
     expiresAt: z.ZodOptional<z.ZodNumber>;
@@ -46,3 +50,155 @@ export declare const sessionEventsQuerySchema: z.ZodObject<{
     limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
     since: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
 }, z.core.$strip>;
+export declare const sessionHeadAdvanceSchema: z.ZodObject<{
+    currentHead: z.ZodString;
+    lastTurnId: z.ZodString;
+    status: z.ZodOptional<z.ZodEnum<{
+        completed: "completed";
+        failed: "failed";
+        cancelled: "cancelled";
+    }>>;
+    basis: z.ZodObject<{
+        turnId: z.ZodString;
+        eventMessageId: z.ZodString;
+        turnSeq: z.ZodNumber;
+        occurredAt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const workspaceSessionStarSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    starred: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const workspaceSessionRecentSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+}, z.core.$strip>;
+export declare const workspaceCwdPinSchema: z.ZodObject<{
+    machineId: z.ZodString;
+    cwd: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const workspaceCwdUnpinSchema: z.ZodObject<{
+    machineId: z.ZodString;
+    cwd: z.ZodString;
+}, z.core.$strip>;
+export declare const workspaceProjectPreferenceSchema: z.ZodObject<{
+    projectKey: z.ZodString;
+    machineId: z.ZodOptional<z.ZodString>;
+    cwd: z.ZodOptional<z.ZodString>;
+    agent: z.ZodOptional<z.ZodString>;
+    memoryMode: z.ZodOptional<z.ZodEnum<{
+        off: "off";
+        readonly: "readonly";
+        readwrite: "readwrite";
+    }>>;
+}, z.core.$strip>;
+export declare const sessionMetadataUpdateSchema: z.ZodObject<{
+    encryptedMetadata: z.ZodObject<{
+        v: z.ZodLiteral<1>;
+        alg: z.ZodLiteral<"A256GCM">;
+        scope: z.ZodString;
+        key: z.ZodObject<{
+            nonce: z.ZodString;
+            ciphertext: z.ZodString;
+        }, z.core.$strip>;
+        data: z.ZodObject<{
+            nonce: z.ZodString;
+            ciphertext: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const memoryListQuerySchema: z.ZodObject<{
+    projectKey: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const memorySaveSchema: z.ZodObject<{
+    id: z.ZodString;
+    projectKey: z.ZodString;
+    encryptedMemory: z.ZodUnknown;
+}, z.core.$strip>;
+export declare const memoryDeleteSchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+export declare const memorySettingsSchema: z.ZodObject<{
+    projectKey: z.ZodString;
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    injectionEnabled: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const machineMemoryDocumentsQuerySchema: z.ZodObject<{
+    projectKey: z.ZodString;
+}, z.core.$strip>;
+export declare const machineMemoryDocumentSaveSchema: z.ZodObject<{
+    id: z.ZodString;
+    projectKey: z.ZodString;
+    encryptedDocument: z.ZodObject<{
+        v: z.ZodLiteral<1>;
+        alg: z.ZodLiteral<"A256GCM">;
+        scope: z.ZodString;
+        key: z.ZodObject<{
+            nonce: z.ZodString;
+            ciphertext: z.ZodString;
+        }, z.core.$strip>;
+        data: z.ZodObject<{
+            nonce: z.ZodString;
+            ciphertext: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const machineCreateSessionAdmissionSchema: z.ZodObject<{
+    requestId: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodString>;
+    agent: z.ZodString;
+    cwd: z.ZodString;
+    name: z.ZodString;
+    model: z.ZodOptional<z.ZodString>;
+    encryptedMetadata: z.ZodOptional<z.ZodObject<{
+        v: z.ZodLiteral<1>;
+        alg: z.ZodLiteral<"A256GCM">;
+        scope: z.ZodString;
+        key: z.ZodObject<{
+            nonce: z.ZodString;
+            ciphertext: z.ZodString;
+        }, z.core.$strip>;
+        data: z.ZodObject<{
+            nonce: z.ZodString;
+            ciphertext: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const machinePromptAdmissionSchema: z.ZodObject<{
+    requestId: z.ZodString;
+    sessionId: z.ZodString;
+    turnId: z.ZodString;
+    encryptedPrompt: z.ZodObject<{
+        v: z.ZodLiteral<1>;
+        alg: z.ZodLiteral<"A256GCM">;
+        scope: z.ZodString;
+        key: z.ZodObject<{
+            nonce: z.ZodString;
+            ciphertext: z.ZodString;
+        }, z.core.$strip>;
+        data: z.ZodObject<{
+            nonce: z.ZodString;
+            ciphertext: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    permissionMode: z.ZodOptional<z.ZodEnum<{
+        "approve-all": "approve-all";
+        "approve-reads": "approve-reads";
+        "deny-all": "deny-all";
+    }>>;
+    model: z.ZodOptional<z.ZodString>;
+    encryptedMemoryOptions: z.ZodOptional<z.ZodObject<{
+        v: z.ZodLiteral<1>;
+        alg: z.ZodLiteral<"A256GCM">;
+        scope: z.ZodString;
+        key: z.ZodObject<{
+            nonce: z.ZodString;
+            ciphertext: z.ZodString;
+        }, z.core.$strip>;
+        data: z.ZodObject<{
+            nonce: z.ZodString;
+            ciphertext: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;

package/apps/relay/dist/http-schemas.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { encryptedEnvelopeSchema } from "../../../packages/shared/dist/index.js";
 export const pairingStartSchema = z.object({
     deviceId: z.string().min(1),
     deviceName: z.string().min(1),
@@ -25,6 +26,10 @@ export const pairingClaimSchema = z.object({
 export const deviceRevokeSchema = z.object({
     deviceId: z.string().min(1),
 });
+export const deviceRenameSchema = z.object({
+    deviceId: z.string().min(1),
+    name: z.string().min(1),
+});
 const scopedTokenScopeSchema = z.object({
     name: z.string().min(1).optional(),
     machines: z.array(z.string().min(1)).nonempty().optional(),
@@ -53,4 +58,84 @@ export const sessionEventsQuerySchema = z.object({
 }).refine((query) => query.beforeCursor === undefined || query.since === undefined, {
     message: "since and beforeCursor cannot both be provided",
 });
+export const sessionHeadAdvanceSchema = z.object({
+    currentHead: z.string().min(1),
+    lastTurnId: z.string().min(1),
+    status: z.enum(["completed", "cancelled", "failed"]).optional(),
+    basis: z.object({
+        turnId: z.string().min(1),
+        eventMessageId: z.string().min(1),
+        turnSeq: z.number().int().min(0),
+        occurredAt: z.number().int().optional(),
+    }),
+});
+export const workspaceSessionStarSchema = z.object({
+    sessionId: z.string().min(1),
+    starred: z.boolean(),
+});
+export const workspaceSessionRecentSchema = z.object({
+    sessionId: z.string().min(1),
+});
+export const workspaceCwdPinSchema = z.object({
+    machineId: z.string().min(1),
+    cwd: z.string().min(1),
+    label: z.string().min(1).optional(),
+});
+export const workspaceCwdUnpinSchema = z.object({
+    machineId: z.string().min(1),
+    cwd: z.string().min(1),
+});
+export const workspaceProjectPreferenceSchema = z.object({
+    projectKey: z.string().min(1),
+    machineId: z.string().min(1).optional(),
+    cwd: z.string().min(1).optional(),
+    agent: z.string().min(1).optional(),
+    memoryMode: z.enum(["off", "readonly", "readwrite"]).optional(),
+});
+export const sessionMetadataUpdateSchema = z.object({
+    encryptedMetadata: encryptedEnvelopeSchema,
+});
+export const memoryListQuerySchema = z.object({
+    projectKey: z.string().min(1).optional(),
+});
+export const memorySaveSchema = z.object({
+    id: z.string().min(1),
+    projectKey: z.string().min(1),
+    encryptedMemory: z.unknown(),
+});
+export const memoryDeleteSchema = z.object({
+    id: z.string().min(1),
+});
+export const memorySettingsSchema = z.object({
+    projectKey: z.string().min(1),
+    disabled: z.boolean().optional(),
+    injectionEnabled: z.boolean().optional(),
+});
+export const machineMemoryDocumentsQuerySchema = z.object({
+    projectKey: z.string().min(1),
+});
+export const machineMemoryDocumentSaveSchema = z.object({
+    id: z.string().min(1),
+    projectKey: z.string().min(1),
+    encryptedDocument: encryptedEnvelopeSchema,
+});
+export const machineCreateSessionAdmissionSchema = z.object({
+    requestId: z.string().min(1),
+    sessionId: z.string().min(1).optional(),
+    agent: z.string().min(1),
+    cwd: z.string(),
+    name: z.string().min(1),
+    model: z.string().min(1).optional(),
+    encryptedMetadata: encryptedEnvelopeSchema.optional(),
+});
+export const machinePromptAdmissionSchema = z.object({
+    requestId: z.string().min(1),
+    sessionId: z.string().min(1),
+    turnId: z.string().min(1),
+    encryptedPrompt: encryptedEnvelopeSchema,
+    permissionMode: z.enum(["approve-all", "approve-reads", "deny-all"]).optional(),
+    model: z.string().min(1).optional(),
+    encryptedMemoryOptions: encryptedEnvelopeSchema.optional(),
+    timeoutMs: z.number().positive().optional(),
+});
 //# sourceMappingURL=http-schemas.js.map

package/apps/relay/dist/index.js

@@ -18,9 +18,11 @@ const dbPath = process.env.HAPPY_ELVES_DB ?? path.join(process.cwd(), ".happy-el
 const pairingTtlMs = 10 * 60 * 1000;
 const controllerInviteTtlMs = 10 * 60 * 1000;
 const eventReplayLimit = intEnv("HAPPY_ELVES_EVENT_REPLAY_LIMIT", process.env.HAPPY_ELVES_EVENT_REPLAY_LIMIT, 100);
+const lanPackDir = process.env.HAPPY_ELVES_LAN_PACK_DIR ? path.resolve(process.env.HAPPY_ELVES_LAN_PACK_DIR) : undefined;
 const retention = createRetentionConfig(process.env);
 const retentionPruneIntervalMs = retentionMs("HAPPY_ELVES_RETENTION_PRUNE_INTERVAL_MS", process.env.HAPPY_ELVES_RETENTION_PRUNE_INTERVAL_MS, 60_000);
 const originAllowed = createOriginPolicy(process.env);
+const fixedNow = process.env.HAPPY_ELVES_TEST_FIXED_NOW ? intEnv("HAPPY_ELVES_TEST_FIXED_NOW", process.env.HAPPY_ELVES_TEST_FIXED_NOW, 0) : undefined;
 function intEnv(name, value, defaultValue) {
     if (value === undefined || value.trim() === "")
         return defaultValue;
@@ -41,6 +43,7 @@ const context = createRelayContext({
     eventReplayLimit,
     pairingTtlMs,
     pruneRetention: createRetentionPruner({ db, config: retention, intervalMs: retentionPruneIntervalMs }),
+    now: fixedNow === undefined ? undefined : () => fixedNow,
 });
 const app = fastify({ logger: { level: process.env.HAPPY_ELVES_RELAY_LOG_LEVEL ?? "info" } });
 await app.register(cors, {
@@ -59,7 +62,7 @@ app.addHook("onRequest", (request, reply, done) => {
 });
 app.setErrorHandler((error, _request, reply) => {
     if (error instanceof HttpError) {
-        reply.code(error.statusCode).send({ error: { code: error.code, message: error.message } });
+        reply.code(error.statusCode).send({ error: { code: error.code, message: error.message, ...(error.details ?? {}) } });
         return;
     }
     if (error instanceof z.ZodError) {
@@ -75,6 +78,33 @@ app.setErrorHandler((error, _request, reply) => {
     }
     reply.code(500).send({ error: { code: "INTERNAL_ERROR", message } });
 });
+if (lanPackDir) {
+    app.get("/__lan/*", async (request, reply) => {
+        const params = request.params;
+        const requested = decodeURIComponent(params["*"] ?? "");
+        const filePath = path.resolve(lanPackDir, requested);
+        if (!filePath.startsWith(`${lanPackDir}${path.sep}`)) {
+            reply.code(403).send("forbidden");
+            return;
+        }
+        let stat;
+        try {
+            stat = fs.statSync(filePath);
+        }
+        catch {
+            reply.code(404).send("not found");
+            return;
+        }
+        if (!stat.isFile()) {
+            reply.code(404).send("not found");
+            return;
+        }
+        const extension = path.extname(filePath);
+        reply.header("content-length", String(stat.size));
+        reply.type(extension === ".ps1" ? "text/plain; charset=utf-8" : extension === ".tgz" ? "application/gzip" : "application/octet-stream");
+        return reply.send(fs.createReadStream(filePath));
+    });
+}
 registerHttpRoutes(app, context, controllerInviteTtlMs);
 registerWebsocketRoute(app, context, originAllowed);
 export async function startRelay(options = {}) {

package/apps/relay/dist/machine-handlers.d.ts

@@ -1,5 +1,5 @@
 import type { DatabaseSync } from "node:sqlite";
-import type { ClientMessage, EncryptedEnvelope, MachineSnapshot, ServerMessage, SessionSnapshot } from "@happy-elves/shared";
+import type { ClientMessage, EncryptedEnvelope, MachineSnapshot, ServerMessage, SessionSnapshot } from "../../../packages/shared/dist/index.js";
 import type { MachineConnection, SessionRow } from "./types.js";
 type MachineHandlerContext = {
     broadcastAck(accountId: string, message: Extract<ServerMessage, {
@@ -11,24 +11,32 @@ type MachineHandlerContext = {
     }>): void;
     clearCommandPending(accountId: string, requestId: string): void;
     db: DatabaseSync;
+    finishSessionClaim(params: {
+        accountId: string;
+        sessionId: string;
+        requestId?: string;
+        turnId?: string;
+        terminalStatus: "completed" | "cancelled" | "failed" | "error" | "unknown";
+        errorCode?: string;
+        finishedAt?: number;
+    }): {
+        request_id: string;
+        turn_id: string;
+    } | undefined;
     insertEvent(params: {
         accountId: string;
         sessionId: string;
         machineId: string;
+        source: "controller" | "machine";
         messageId?: string;
         turnId: string;
         turnSeq?: number;
         occurredAt?: number;
         payload: EncryptedEnvelope;
+        updateSession?: boolean;
     }): Extract<ServerMessage, {
         type: "server:event";
     }>["event"];
-    aliasedRuntimeEventHasRequestEvents(params: {
-        accountId: string;
-        sessionId: string;
-        machineId: string;
-        runtimeTurnId: string;
-    }): boolean;
     machineMessageProcessed(accountId: string, machineId: string, messageId: string): boolean;
     markMachineMessageProcessed(accountId: string, machineId: string, messageId: string): void;
     now(): number;