@agentdock/wire 0.4.0

package/dist/messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../src/messages.ts"],"names":[],"mappings":"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"}

package/dist/messages.js

@@ -0,0 +1,35 @@
+/**
+ * Message schemas — aligned with Happy messages.ts.
+ *
+ * SessionMessage: encrypted content container.
+ * Timestamps are Unix numbers (milliseconds).
+ */
+import { z } from 'zod';
+import { SessionEnvelopeSchema } from './envelope.js';
+import { MessageMetaSchema } from './messageMeta.js';
+import { UserMessageSchema, AgentMessageSchema } from './legacyProtocol.js';
+export const SessionMessageContentSchema = z.object({
+    c: z.string(),
+    t: z.literal('encrypted'),
+});
+export const SessionMessageSchema = z.object({
+    id: z.string(),
+    seq: z.number(),
+    localId: z.string().nullish(),
+    content: SessionMessageContentSchema,
+    createdAt: z.number(),
+    updatedAt: z.number(),
+});
+// ── SessionProtocolMessage (bridges envelope into message content) ──
+export const SessionProtocolMessageSchema = z.object({
+    role: z.literal('session'),
+    content: SessionEnvelopeSchema,
+    meta: MessageMetaSchema.optional(),
+});
+// ── MessageContent (union of all message content types) ─────────────
+export const MessageContentSchema = z.discriminatedUnion('role', [
+    UserMessageSchema,
+    AgentMessageSchema,
+    SessionProtocolMessageSchema,
+]);
+//# sourceMappingURL=messages.js.map

package/dist/messages.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.js","sourceRoot":"","sources":["../src/messages.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AACtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAE5E,MAAM,CAAC,MAAM,2BAA2B,GAAG,CAAC,CAAC,MAAM,CAAC;IAClD,CAAC,EAAE,CAAC,CAAC,MAAM,EAAE;IACb,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,WAAW,CAAC;CAC1B,CAAC,CAAC;AAGH,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC3C,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE;IACd,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE;IACf,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE;IAC7B,OAAO,EAAE,2BAA2B;IACpC,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE;IACrB,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE;CACtB,CAAC,CAAC;AAIH,uEAAuE;AAEvE,MAAM,CAAC,MAAM,4BAA4B,GAAG,CAAC,CAAC,MAAM,CAAC;IACnD,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC;IAC1B,OAAO,EAAE,qBAAqB;IAC9B,IAAI,EAAE,iBAAiB,CAAC,QAAQ,EAAE;CACnC,CAAC,CAAC;AAGH,uEAAuE;AAEvE,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAC,kBAAkB,CAAC,MAAM,EAAE;IAC/D,iBAAiB;IACjB,kBAAkB;IAClB,4BAA4B;CAC7B,CAAC,CAAC"}

package/dist/pairing.d.ts

@@ -0,0 +1,133 @@
+/**
+ * Pairing protocol schemas.
+ *
+ * Defines the wire format for device pairing:
+ * - PairingRequest: CLI sends publicKey + optional PIN to server
+ * - PairingResponse: Web sends encrypted payload back via server
+ * - PairingStatus: Polling response — discriminated union on state
+ *
+ * Security: Uses NaCl Box (Curve25519 + XSalsa20-Poly1305) for key exchange.
+ * PIN code provides iOS PWA fallback where QR scanning is unreliable.
+ */
+import { z } from 'zod';
+/** Pairing state machine. */
+export declare const PairingState: z.ZodEnum<["pending", "exchange", "authorized", "expired"]>;
+/**
+ * CLI → Server: initiate a pairing request.
+ *
+ * publicKey: base64-encoded Curve25519 public key (32 bytes)
+ * pin: optional 6-digit PIN for manual entry (iOS PWA fallback)
+ * label: optional human-readable device label
+ */
+export declare const PairingRequestSchema: z.ZodObject<{
+    publicKey: z.ZodEffects<z.ZodString, string, string>;
+    pin: z.ZodOptional<z.ZodString>;
+    label: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodEnum<["join", "invite"]>>;
+}, "strip", z.ZodTypeAny, {
+    publicKey: string;
+    type?: "join" | "invite" | undefined;
+    label?: string | undefined;
+    pin?: string | undefined;
+}, {
+    publicKey: string;
+    type?: "join" | "invite" | undefined;
+    label?: string | undefined;
+    pin?: string | undefined;
+}>;
+/**
+ * Web → Server: approve pairing with encrypted key material.
+ *
+ * publicKey: identifies which pairing request to respond to (32-byte Curve25519 key)
+ * encryptedPayload: NaCl Box encrypted data (base64) containing the DEK
+ */
+export declare const PairingResponseSchema: z.ZodObject<{
+    publicKey: z.ZodEffects<z.ZodString, string, string>;
+    encryptedPayload: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    publicKey: string;
+    encryptedPayload: string;
+}, {
+    publicKey: string;
+    encryptedPayload: string;
+}>;
+/**
+ * New device → Server: submit device's temporary Curve25519 public key.
+ * Used in invite flow when a new device joins an existing account.
+ */
+export declare const PairingExchangeSchema: z.ZodObject<{
+    daemonPublicKey: z.ZodEffects<z.ZodString, string, string>;
+    devicePublicKey: z.ZodEffects<z.ZodString, string, string>;
+}, "strip", z.ZodTypeAny, {
+    daemonPublicKey: string;
+    devicePublicKey: string;
+}, {
+    daemonPublicKey: string;
+    devicePublicKey: string;
+}>;
+/**
+ * Daemon → Server: deliver encrypted master secret to new device.
+ * Requires Bearer auth. Encrypted via NaCl Box using device's public key.
+ */
+export declare const PairingDeliverSchema: z.ZodObject<{
+    publicKey: z.ZodEffects<z.ZodString, string, string>;
+    encryptedPayload: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    publicKey: string;
+    encryptedPayload: string;
+}, {
+    publicKey: string;
+    encryptedPayload: string;
+}>;
+export declare const PairingStatusSchema: z.ZodDiscriminatedUnion<"state", [z.ZodObject<{
+    state: z.ZodLiteral<"pending">;
+    publicKey: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    publicKey: string;
+    state: "pending";
+}, {
+    publicKey: string;
+    state: "pending";
+}>, z.ZodObject<{
+    state: z.ZodLiteral<"exchange">;
+    publicKey: z.ZodString;
+    devicePublicKey: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    publicKey: string;
+    devicePublicKey: string;
+    state: "exchange";
+}, {
+    publicKey: string;
+    devicePublicKey: string;
+    state: "exchange";
+}>, z.ZodObject<{
+    state: z.ZodLiteral<"authorized">;
+    publicKey: z.ZodString;
+    encryptedPayload: z.ZodString;
+    token: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    publicKey: string;
+    encryptedPayload: string;
+    state: "authorized";
+    token: string;
+}, {
+    publicKey: string;
+    encryptedPayload: string;
+    state: "authorized";
+    token: string;
+}>, z.ZodObject<{
+    state: z.ZodLiteral<"expired">;
+    publicKey: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    publicKey: string;
+    state: "expired";
+}, {
+    publicKey: string;
+    state: "expired";
+}>]>;
+export type PairingRequest = z.infer<typeof PairingRequestSchema>;
+export type PairingResponse = z.infer<typeof PairingResponseSchema>;
+export type PairingExchange = z.infer<typeof PairingExchangeSchema>;
+export type PairingDeliver = z.infer<typeof PairingDeliverSchema>;
+export type PairingStatus = z.infer<typeof PairingStatusSchema>;
+//# sourceMappingURL=pairing.d.ts.map

package/dist/pairing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pairing.d.ts","sourceRoot":"","sources":["../src/pairing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,6BAA6B;AAC7B,eAAO,MAAM,YAAY,6DAA2D,CAAC;AA8BrF;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;EAK/B,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;EAGhC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;EAGhC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;EAG/B,CAAC;AAgCH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAK9B,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/dist/pairing.js

@@ -0,0 +1,115 @@
+/**
+ * Pairing protocol schemas.
+ *
+ * Defines the wire format for device pairing:
+ * - PairingRequest: CLI sends publicKey + optional PIN to server
+ * - PairingResponse: Web sends encrypted payload back via server
+ * - PairingStatus: Polling response — discriminated union on state
+ *
+ * Security: Uses NaCl Box (Curve25519 + XSalsa20-Poly1305) for key exchange.
+ * PIN code provides iOS PWA fallback where QR scanning is unreliable.
+ */
+import { z } from 'zod';
+/** 6-digit numeric PIN for iOS PWA fallback. */
+const PinSchema = z.string().regex(/^\d{6}$/, 'PIN must be exactly 6 digits');
+/** Pairing state machine. */
+export const PairingState = z.enum(['pending', 'exchange', 'authorized', 'expired']);
+/**
+ * Validates that a string is a base64/base64url-encoded 32-byte Curve25519 public key.
+ * Accepts both standard base64 (with padding) and base64url (without padding).
+ */
+/**
+ * Check if a base64/base64url string decodes to exactly `expectedBytes` bytes.
+ * Uses string-length math: 4 base64 chars = 3 bytes.
+ * No runtime decoding needed — just validate charset + length.
+ */
+function isBase64OfLength(val, expectedBytes) {
+    // Must be non-empty and only valid base64/base64url characters
+    if (!/^[A-Za-z0-9+/\-_]+=*$/.test(val))
+        return false;
+    // Normalize base64url → standard base64
+    const b64 = val.replace(/-/g, '+').replace(/_/g, '/');
+    const padded = b64.padEnd(b64.length + ((4 - (b64.length % 4)) % 4), '=');
+    // Count padding
+    const paddingCount = (padded.match(/=+$/) ?? [''])[0].length;
+    const totalBytes = (padded.length / 4) * 3 - paddingCount;
+    return totalBytes === expectedBytes;
+}
+const Curve25519PublicKeySchema = z
+    .string()
+    .min(1)
+    .refine((val) => isBase64OfLength(val, 32), {
+    message: 'publicKey must be a base64-encoded 32-byte Curve25519 key',
+});
+/**
+ * CLI → Server: initiate a pairing request.
+ *
+ * publicKey: base64-encoded Curve25519 public key (32 bytes)
+ * pin: optional 6-digit PIN for manual entry (iOS PWA fallback)
+ * label: optional human-readable device label
+ */
+export const PairingRequestSchema = z.object({
+    publicKey: Curve25519PublicKeySchema,
+    pin: PinSchema.optional(),
+    label: z.string().max(100).optional(),
+    type: z.enum(['join', 'invite']).optional(),
+});
+/**
+ * Web → Server: approve pairing with encrypted key material.
+ *
+ * publicKey: identifies which pairing request to respond to (32-byte Curve25519 key)
+ * encryptedPayload: NaCl Box encrypted data (base64) containing the DEK
+ */
+export const PairingResponseSchema = z.object({
+    publicKey: Curve25519PublicKeySchema,
+    encryptedPayload: z.string().min(1),
+});
+/**
+ * New device → Server: submit device's temporary Curve25519 public key.
+ * Used in invite flow when a new device joins an existing account.
+ */
+export const PairingExchangeSchema = z.object({
+    daemonPublicKey: Curve25519PublicKeySchema,
+    devicePublicKey: Curve25519PublicKeySchema,
+});
+/**
+ * Daemon → Server: deliver encrypted master secret to new device.
+ * Requires Bearer auth. Encrypted via NaCl Box using device's public key.
+ */
+export const PairingDeliverSchema = z.object({
+    publicKey: Curve25519PublicKeySchema,
+    encryptedPayload: z.string().min(1),
+});
+/**
+ * Server → CLI: current pairing status (polled).
+ * Discriminated union on `state`:
+ * - pending: waiting for web approval
+ * - authorized: web approved, encryptedPayload + token required
+ * - expired: request timed out
+ */
+const PairingStatusPending = z.object({
+    state: z.literal('pending'),
+    publicKey: z.string().min(1),
+});
+const PairingStatusExchange = z.object({
+    state: z.literal('exchange'),
+    publicKey: z.string().min(1),
+    devicePublicKey: z.string().min(1),
+});
+const PairingStatusAuthorized = z.object({
+    state: z.literal('authorized'),
+    publicKey: z.string().min(1),
+    encryptedPayload: z.string().min(1),
+    token: z.string().min(1),
+});
+const PairingStatusExpired = z.object({
+    state: z.literal('expired'),
+    publicKey: z.string().min(1),
+});
+export const PairingStatusSchema = z.discriminatedUnion('state', [
+    PairingStatusPending,
+    PairingStatusExchange,
+    PairingStatusAuthorized,
+    PairingStatusExpired,
+]);
+//# sourceMappingURL=pairing.js.map

package/dist/pairing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pairing.js","sourceRoot":"","sources":["../src/pairing.ts"],"names":[],"mappings":"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"}

package/dist/rpc.d.ts

@@ -0,0 +1,340 @@
+import { z } from 'zod';
+export declare const RpcMethod: z.ZodEnum<["spawn-session", "stop-session", "abort", "switch-mode", "approve-permission", "deny-permission", "answer-question", "shutdown-daemon", "get-messages", "get-stats", "get-team-stats", "start-invite", "get-machine-info", "get-agent-settings", "set-agent-settings"]>;
+/**
+ * Session-scoped RPC methods — registered by `agentbox start` (CLI process).
+ * These operate on a specific session and require the CLI to be running.
+ */
+export declare const SESSION_RPC_METHODS: readonly ["answer-question", "approve-permission", "deny-permission", "abort", "stop-session"];
+/**
+ * Machine-scoped RPC methods — registered by the persistent daemon only.
+ * These are account/machine-level operations independent of any session.
+ */
+export declare const MACHINE_RPC_METHODS: readonly ["start-invite", "get-machine-info", "get-agent-settings", "set-agent-settings"];
+/**
+ * All RPC methods that must be registered for Web UI to function.
+ * Daemon registers MACHINE_RPC_METHODS; CLI registers SESSION_RPC_METHODS.
+ *
+ * @deprecated Use SESSION_RPC_METHODS or MACHINE_RPC_METHODS directly.
+ */
+export declare const DAEMON_REQUIRED_RPC_METHODS: readonly ["answer-question", "approve-permission", "deny-permission", "abort", "stop-session", "start-invite", "get-machine-info", "get-agent-settings", "set-agent-settings"];
+export declare const RpcCallSchema: z.ZodObject<{
+    method: z.ZodString;
+    params: z.ZodUnknown;
+    timeout: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    method: string;
+    timeout: number;
+    params?: unknown;
+}, {
+    method: string;
+    params?: unknown;
+    timeout?: number | undefined;
+}>;
+export declare const RpcResultSchema: z.ZodDiscriminatedUnion<"ok", [z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    result: z.ZodUnknown;
+}, "strip", z.ZodTypeAny, {
+    ok: true;
+    result?: unknown;
+}, {
+    ok: true;
+    result?: unknown;
+}>, z.ZodObject<{
+    ok: z.ZodLiteral<false>;
+    error: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    error: string;
+    ok: false;
+}, {
+    error: string;
+    ok: false;
+}>]>;
+export declare const SpawnSessionParamsSchema: z.ZodObject<{
+    cli: z.ZodEnum<["claude", "copilot", "opencode", "codex", "gemini", "qwen"]>;
+    cwd: z.ZodString;
+    prompt: z.ZodOptional<z.ZodString>;
+    permissionMode: z.ZodDefault<z.ZodEnum<["default", "acceptEdits", "bypassPermissions", "plan", "read-only", "safe-yolo", "yolo"]>>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    model: z.ZodOptional<z.ZodString>;
+    baseUrl: z.ZodOptional<z.ZodString>;
+    /** System prompt text appended to the agent's built-in system prompt. */
+    appendSystemPrompt: z.ZodOptional<z.ZodString>;
+    /** Restrict agent to only these tools (Claude CLI --allowedTools). */
+    allowedTools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Deny agent from using these tools (Claude CLI --disallowedTools). */
+    disallowedTools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** MCP server config JSON string (Claude CLI --mcp-config). */
+    mcpConfig: z.ZodOptional<z.ZodString>;
+    /** Resume a previous session by ID (Claude CLI --resume). */
+    resumeSessionId: z.ZodOptional<z.ZodString>;
+    /** Server session ID to reuse (skip creating new session on resume). */
+    serverSessionId: z.ZodOptional<z.ZodString>;
+    /** Maximum conversation turns before auto-stop (Claude CLI --max-turns). */
+    maxTurns: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    permissionMode: "default" | "acceptEdits" | "plan" | "bypassPermissions" | "read-only" | "safe-yolo" | "yolo";
+    cli: "claude" | "copilot" | "opencode" | "codex" | "gemini" | "qwen";
+    cwd: string;
+    model?: string | undefined;
+    appendSystemPrompt?: string | undefined;
+    allowedTools?: string[] | undefined;
+    disallowedTools?: string[] | undefined;
+    prompt?: string | undefined;
+    env?: Record<string, string> | undefined;
+    baseUrl?: string | undefined;
+    mcpConfig?: string | undefined;
+    resumeSessionId?: string | undefined;
+    serverSessionId?: string | undefined;
+    maxTurns?: number | undefined;
+}, {
+    cli: "claude" | "copilot" | "opencode" | "codex" | "gemini" | "qwen";
+    cwd: string;
+    permissionMode?: "default" | "acceptEdits" | "plan" | "bypassPermissions" | "read-only" | "safe-yolo" | "yolo" | undefined;
+    model?: string | undefined;
+    appendSystemPrompt?: string | undefined;
+    allowedTools?: string[] | undefined;
+    disallowedTools?: string[] | undefined;
+    prompt?: string | undefined;
+    env?: Record<string, string> | undefined;
+    baseUrl?: string | undefined;
+    mcpConfig?: string | undefined;
+    resumeSessionId?: string | undefined;
+    serverSessionId?: string | undefined;
+    maxTurns?: number | undefined;
+}>;
+export declare const GetMessagesParamsSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    fromSeq: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    sessionId: string;
+    limit: number;
+    fromSeq?: number | undefined;
+}, {
+    sessionId: string;
+    fromSeq?: number | undefined;
+    limit?: number | undefined;
+}>;
+export declare const GetMessagesResponseSchema: z.ZodObject<{
+    messages: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        seq: z.ZodNumber;
+        localId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        content: z.ZodObject<{
+            c: z.ZodString;
+            t: z.ZodLiteral<"encrypted">;
+        }, "strip", z.ZodTypeAny, {
+            t: "encrypted";
+            c: string;
+        }, {
+            t: "encrypted";
+            c: string;
+        }>;
+        createdAt: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        createdAt: number;
+        content: {
+            t: "encrypted";
+            c: string;
+        };
+        seq: number;
+        updatedAt: number;
+        localId?: string | null | undefined;
+    }, {
+        id: string;
+        createdAt: number;
+        content: {
+            t: "encrypted";
+            c: string;
+        };
+        seq: number;
+        updatedAt: number;
+        localId?: string | null | undefined;
+    }>, "many">;
+    total: z.ZodNumber;
+    hasMore: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    messages: {
+        id: string;
+        createdAt: number;
+        content: {
+            t: "encrypted";
+            c: string;
+        };
+        seq: number;
+        updatedAt: number;
+        localId?: string | null | undefined;
+    }[];
+    total: number;
+    hasMore: boolean;
+}, {
+    messages: {
+        id: string;
+        createdAt: number;
+        content: {
+            t: "encrypted";
+            c: string;
+        };
+        seq: number;
+        updatedAt: number;
+        localId?: string | null | undefined;
+    }[];
+    total: number;
+    hasMore: boolean;
+}>;
+export declare const MachineInfoResponseSchema: z.ZodObject<{
+    homedir: z.ZodString;
+    recentCwds: z.ZodArray<z.ZodString, "many">;
+    availableAgents: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    homedir: string;
+    recentCwds: string[];
+    availableAgents: string[];
+}, {
+    homedir: string;
+    recentCwds: string[];
+    availableAgents: string[];
+}>;
+export declare const AgentEnvConfigSchema: z.ZodObject<{
+    httpProxy: z.ZodOptional<z.ZodString>;
+    httpsProxy: z.ZodOptional<z.ZodString>;
+    customEnv: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    httpProxy?: string | undefined;
+    httpsProxy?: string | undefined;
+    customEnv?: Record<string, string> | undefined;
+}, {
+    httpProxy?: string | undefined;
+    httpsProxy?: string | undefined;
+    customEnv?: Record<string, string> | undefined;
+}>;
+export declare const AgentSettingsSchema: z.ZodObject<{
+    claude: z.ZodOptional<z.ZodObject<{
+        httpProxy: z.ZodOptional<z.ZodString>;
+        httpsProxy: z.ZodOptional<z.ZodString>;
+        customEnv: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        httpProxy?: string | undefined;
+        httpsProxy?: string | undefined;
+        customEnv?: Record<string, string> | undefined;
+    }, {
+        httpProxy?: string | undefined;
+        httpsProxy?: string | undefined;
+        customEnv?: Record<string, string> | undefined;
+    }>>;
+    copilot: z.ZodOptional<z.ZodObject<{
+        httpProxy: z.ZodOptional<z.ZodString>;
+        httpsProxy: z.ZodOptional<z.ZodString>;
+        customEnv: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        httpProxy?: string | undefined;
+        httpsProxy?: string | undefined;
+        customEnv?: Record<string, string> | undefined;
+    }, {
+        httpProxy?: string | undefined;
+        httpsProxy?: string | undefined;
+        customEnv?: Record<string, string> | undefined;
+    }>>;
+    codex: z.ZodOptional<z.ZodObject<{
+        httpProxy: z.ZodOptional<z.ZodString>;
+        httpsProxy: z.ZodOptional<z.ZodString>;
+        customEnv: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        httpProxy?: string | undefined;
+        httpsProxy?: string | undefined;
+        customEnv?: Record<string, string> | undefined;
+    }, {
+        httpProxy?: string | undefined;
+        httpsProxy?: string | undefined;
+        customEnv?: Record<string, string> | undefined;
+    }>>;
+    gemini: z.ZodOptional<z.ZodObject<{
+        httpProxy: z.ZodOptional<z.ZodString>;
+        httpsProxy: z.ZodOptional<z.ZodString>;
+        customEnv: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        httpProxy?: string | undefined;
+        httpsProxy?: string | undefined;
+        customEnv?: Record<string, string> | undefined;
+    }, {
+        httpProxy?: string | undefined;
+        httpsProxy?: string | undefined;
+        customEnv?: Record<string, string> | undefined;
+    }>>;
+    opencode: z.ZodOptional<z.ZodObject<{
+        httpProxy: z.ZodOptional<z.ZodString>;
+        httpsProxy: z.ZodOptional<z.ZodString>;
+        customEnv: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        httpProxy?: string | undefined;
+        httpsProxy?: string | undefined;
+        customEnv?: Record<string, string> | undefined;
+    }, {
+        httpProxy?: string | undefined;
+        httpsProxy?: string | undefined;
+        customEnv?: Record<string, string> | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    claude?: {
+        httpProxy?: string | undefined;
+        httpsProxy?: string | undefined;
+        customEnv?: Record<string, string> | undefined;
+    } | undefined;
+    copilot?: {
+        httpProxy?: string | undefined;
+        httpsProxy?: string | undefined;
+        customEnv?: Record<string, string> | undefined;
+    } | undefined;
+    opencode?: {
+        httpProxy?: string | undefined;
+        httpsProxy?: string | undefined;
+        customEnv?: Record<string, string> | undefined;
+    } | undefined;
+    codex?: {
+        httpProxy?: string | undefined;
+        httpsProxy?: string | undefined;
+        customEnv?: Record<string, string> | undefined;
+    } | undefined;
+    gemini?: {
+        httpProxy?: string | undefined;
+        httpsProxy?: string | undefined;
+        customEnv?: Record<string, string> | undefined;
+    } | undefined;
+}, {
+    claude?: {
+        httpProxy?: string | undefined;
+        httpsProxy?: string | undefined;
+        customEnv?: Record<string, string> | undefined;
+    } | undefined;
+    copilot?: {
+        httpProxy?: string | undefined;
+        httpsProxy?: string | undefined;
+        customEnv?: Record<string, string> | undefined;
+    } | undefined;
+    opencode?: {
+        httpProxy?: string | undefined;
+        httpsProxy?: string | undefined;
+        customEnv?: Record<string, string> | undefined;
+    } | undefined;
+    codex?: {
+        httpProxy?: string | undefined;
+        httpsProxy?: string | undefined;
+        customEnv?: Record<string, string> | undefined;
+    } | undefined;
+    gemini?: {
+        httpProxy?: string | undefined;
+        httpsProxy?: string | undefined;
+        customEnv?: Record<string, string> | undefined;
+    } | undefined;
+}>;
+export type RpcCall = z.infer<typeof RpcCallSchema>;
+export type RpcResult = z.infer<typeof RpcResultSchema>;
+export type SpawnSessionParams = z.infer<typeof SpawnSessionParamsSchema>;
+export type GetMessagesParams = z.infer<typeof GetMessagesParamsSchema>;
+export type GetMessagesResponse = z.infer<typeof GetMessagesResponseSchema>;
+export type MachineInfoResponse = z.infer<typeof MachineInfoResponseSchema>;
+export type AgentEnvConfig = z.infer<typeof AgentEnvConfigSchema>;
+export type AgentSettings = z.infer<typeof AgentSettingsSchema>;
+//# sourceMappingURL=rpc.d.ts.map

package/dist/rpc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc.d.ts","sourceRoot":"","sources":["../src/rpc.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,SAAS,oRAgBpB,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,mBAAmB,gGAMyB,CAAC;AAE1D;;;GAGG;AACH,eAAO,MAAM,mBAAmB,2FAKyB,CAAC;AAE1D;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B,gLAGiB,CAAC;AAE1D,eAAO,MAAM,aAAa;;;;;;;;;;;;EAIxB,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;IAG1B,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;IAUnC,yEAAyE;;IAEzE,sEAAsE;;IAEtE,wEAAwE;;IAExE,+DAA+D;;IAE/D,6DAA6D;;IAE7D,wEAAwE;;IAExE,4EAA4E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE5E,CAAC;AAIH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;EAIlC,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIpC,CAAC;AAIH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;EAIpC,CAAC;AAIH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;EAI/B,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAM9B,CAAC;AAEH,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AACpD,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AACxD,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}