@agentdock/wire 0.0.71 → 0.0.73

package/dist/ops.js

@@ -1 +1,74 @@
-"use strict";import{z as e}from"zod";export const OpsMethodSchema=e.string().min(1).regex(/^[a-z]+\.[a-z][a-z0-9-]*$/),OpsRpcTypeSchema=e.enum(["request","response","event"]),OpsRpcMessageSchema=e.object({id:e.string().min(1),type:OpsRpcTypeSchema,method:OpsMethodSchema,payload:e.unknown()}),FileEntrySchema=e.object({name:e.string(),type:e.enum(["file","directory"]),size:e.number().int().nonnegative(),modifiedAt:e.number(),mimeType:e.string().optional()}),FileStatSchema=e.object({name:e.string(),path:e.string(),type:e.enum(["file","directory"]),size:e.number().int().nonnegative(),modifiedAt:e.string(),createdAt:e.string(),mimeType:e.string().optional()}),StorageUsageSchema=e.object({used:e.number().int().nonnegative(),limit:e.number().int().nonnegative(),fileCount:e.number().int().nonnegative()}),SyncUserSchema=e.object({username:e.string().min(1),displayName:e.string(),machineId:e.string().nullable(),containerStatus:e.string(),healthStatus:e.string().nullable(),enabled:e.boolean()}),SyncFullPayloadSchema=e.object({users:e.array(SyncUserSchema)}),SyncUserCreatedPayloadSchema=e.object({username:e.string().min(1),displayName:e.string()}),SyncContainerStatusPayloadSchema=e.object({username:e.string().min(1),containerStatus:e.string(),healthStatus:e.string().nullable().optional()}),SyncUserPairedPayloadSchema=e.object({username:e.string().min(1),machineId:e.string().min(1)});
+import { z } from 'zod';
+/**
+ * Ops RPC method naming convention: namespace.action
+ * - file.*   — RFC-033 file management
+ * - sync.*   — RFC-034 data sync (Ops Agent → Server)
+ * - config.* — RFC-034 policy push (Server → Ops Agent)
+ */
+export const OpsMethodSchema = z
+    .string()
+    .min(1)
+    .regex(/^[a-z]+\.[a-z][a-z0-9-]*$/);
+export const OpsRpcTypeSchema = z.enum(['request', 'response', 'event']);
+/** Unified RPC message over the ops-upstream tunnel. */
+export const OpsRpcMessageSchema = z.object({
+    id: z.string().min(1),
+    type: OpsRpcTypeSchema,
+    method: OpsMethodSchema,
+    payload: z.unknown(),
+});
+// FileEntry — directory listing item (shared by Ops RPC tunnel and REST API).
+export const FileEntrySchema = z.object({
+    name: z.string(),
+    type: z.enum(['file', 'directory']),
+    size: z.number().int().nonnegative(),
+    modifiedAt: z.number(),
+    mimeType: z.string().optional(),
+});
+// FileStat — detailed metadata
+export const FileStatSchema = z.object({
+    name: z.string(),
+    path: z.string(),
+    type: z.enum(['file', 'directory']),
+    size: z.number().int().nonnegative(),
+    modifiedAt: z.string(),
+    createdAt: z.string(),
+    mimeType: z.string().optional(),
+});
+// StorageUsage — quota info
+export const StorageUsageSchema = z.object({
+    used: z.number().int().nonnegative(),
+    limit: z.number().int().nonnegative(),
+    fileCount: z.number().int().nonnegative(),
+});
+// ─── Sync payloads (RFC-034 P1) ─────────────────────────
+/** A single user record in a full sync push. */
+export const SyncUserSchema = z.object({
+    username: z.string().min(1),
+    displayName: z.string(),
+    machineId: z.string().nullable(),
+    containerStatus: z.string(),
+    healthStatus: z.string().nullable(),
+    enabled: z.boolean(),
+});
+/** sync.full — all users pushed on tunnel connect/reconnect. */
+export const SyncFullPayloadSchema = z.object({
+    users: z.array(SyncUserSchema),
+});
+/** sync.user-created — single user just created. */
+export const SyncUserCreatedPayloadSchema = z.object({
+    username: z.string().min(1),
+    displayName: z.string(),
+});
+/** sync.container-status — container state change. */
+export const SyncContainerStatusPayloadSchema = z.object({
+    username: z.string().min(1),
+    containerStatus: z.string(),
+    healthStatus: z.string().nullable().optional(),
+});
+/** sync.user-paired — daemon pairing detected, machineId available. */
+export const SyncUserPairedPayloadSchema = z.object({
+    username: z.string().min(1),
+    machineId: z.string().min(1),
+});
+//# sourceMappingURL=ops.js.map

package/dist/ops.js.map

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

package/dist/pairing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pairing.d.ts","sourceRoot":"","sources":["../src/pairing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,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;AAEhE,6CAA6C;AAC7C,eAAO,MAAM,yBAAyB,aAAkB,CAAC;AAEzD;;;GAGG;AACH,eAAO,MAAM,0BAA0B,IAAI,CAAC;AAE5C;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,YAAY,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,GAAG,UAAU,CAKvF;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,UAAU,GACrB;IAAE,YAAY,EAAE,UAAU,CAAC;IAAC,iBAAiB,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAShE"}

package/dist/pairing.js

@@ -1 +1,150 @@
-"use strict";import{z as e}from"zod";const o=e.string().regex(/^\d{6}$/,"PIN must be exactly 6 digits");export const PairingState=e.enum(["pending","exchange","authorized","expired"]);function a(t,r){if(!/^[A-Za-z0-9+/\-_]+=*$/.test(t))return!1;const n=t.replace(/-/g,"+").replace(/_/g,"/"),c=n.padEnd(n.length+(4-n.length%4)%4,"="),s=(c.match(/=+$/)??[""])[0].length;return c.length/4*3-s===r}const i=e.string().min(1).refine(t=>a(t,32),{message:"publicKey must be a base64-encoded 32-byte Curve25519 key"});export const PairingRequestSchema=e.object({publicKey:i,pin:o.optional(),label:e.string().max(100).optional(),type:e.enum(["join","invite"]).optional()}),PairingResponseSchema=e.object({publicKey:i,encryptedPayload:e.string().min(1)}),PairingExchangeSchema=e.object({daemonPublicKey:i,devicePublicKey:i}),PairingDeliverSchema=e.object({publicKey:i,encryptedPayload:e.string().min(1)});const g=e.object({state:e.literal("pending"),publicKey:e.string().min(1)}),l=e.object({state:e.literal("exchange"),publicKey:e.string().min(1),devicePublicKey:e.string().min(1)}),u=e.object({state:e.literal("authorized"),publicKey:e.string().min(1),encryptedPayload:e.string().min(1),token:e.string().min(1)}),p=e.object({state:e.literal("expired"),publicKey:e.string().min(1)});export const PairingStatusSchema=e.discriminatedUnion("state",[g,l,u,p]),KNOWN_DERIVATION_VERSIONS=new Set([0,1]),CURRENT_DERIVATION_VERSION=1;export function encodeVersionByte(t,r){const n=new Uint8Array(1+t.length);return n[0]=r,n.set(t,1),n}export function parseVersionByte(t){return t.length===33&&t[0]!==void 0?KNOWN_DERIVATION_VERSIONS.has(t[0])?{masterSecret:t.slice(1),derivationVersion:t[0]}:null:t.length===32?{masterSecret:t,derivationVersion:0}:null}
+/**
+ * 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.
+ */
+// KNOWN-DEBT: KNOWN_DERIVATION_VERSIONS 预导出无跨包消费者 (see docs/ops/KNOWN-DEBT.md)
+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,
+]);
+/** Known derivation versions (whitelist). */
+export const KNOWN_DERIVATION_VERSIONS = new Set([0, 1]);
+/**
+ * Current derivation version for newly created identities.
+ * 0 = legacy ('Happy EnCoder'), 1 = CCPark ('CCPark EnCoder').
+ */
+export const CURRENT_DERIVATION_VERSION = 1;
+/**
+ * Encode a master secret with its derivation version as a pairing payload.
+ * Inverse of {@link parseVersionByte}: produces [version_byte, ...masterSecret] (33 bytes).
+ */
+export function encodeVersionByte(masterSecret, version) {
+    const payload = new Uint8Array(1 + masterSecret.length);
+    payload[0] = version;
+    payload.set(masterSecret, 1);
+    return payload;
+}
+/**
+ * Parse derivation version from decrypted pairing payload.
+ * Version 1+: payload = [version_byte, ...masterSecret] (33 bytes)
+ * Version 0 (legacy): payload = masterSecret (32 bytes, no prefix)
+ * Returns null for unknown versions or unexpected lengths.
+ */
+export function parseVersionByte(rawPayload) {
+    if (rawPayload.length === 33 && rawPayload[0] !== undefined) {
+        if (!KNOWN_DERIVATION_VERSIONS.has(rawPayload[0]))
+            return null;
+        return { masterSecret: rawPayload.slice(1), derivationVersion: rawPayload[0] };
+    }
+    if (rawPayload.length === 32) {
+        return { masterSecret: rawPayload, derivationVersion: 0 };
+    }
+    return null;
+}
+//# 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/permissionSubject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permissionSubject.d.ts","sourceRoot":"","sources":["../src/permissionSubject.ts"],"names":[],"mappings":"AAgBA;;;;;GAKG;AACH,eAAO,MAAM,eAAe,EAAE,WAAW,CAAC,MAAM,CAAiD,CAAC;AAElG,2EAA2E;AAC3E,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAExD;AAED;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAqB7D;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,IAAI,CAAC"}

package/dist/permissionSubject.js

@@ -1 +1,68 @@
-"use strict";export const BASH_TOOL_NAMES=new Set(["Bash","bash","execute","shell"]);export function isBashToolName(n){return BASH_TOOL_NAMES.has(n)}export function extractCommandSubject(n){const e=n.trim();if(!e)return"";let t;if(e[0]==='"'||e[0]==="'"){const c=e[0],o=e.indexOf(c,1);t=o>0?e.slice(1,o):e.slice(1)}else t=e.split(/\s+/)[0]??e;const s=t.split(/[/\\]/).pop();return(s||t).replace(/^["']|["']$/g,"")}export const MIN_SUBJECT_LENGTH=2;
+// permission-subject — single source of truth for Bash-like command subject
+// extraction. Shared by the web rule generator (useInteraction.makeRuleIdentifier)
+// and the daemon matcher (permissionRuleStore.extractSubject).
+//
+// WHY HERE: web and daemon are the two consumers; wire is their only common
+// upstream (wire→…→web, wire→…→daemon). Doing the first-token/basename transform
+// in ONE place stops the two sides from drifting apart. When they drift:
+//   - front-end stores a rule the daemon can never match → "allow and don't ask
+//     again" silently keeps re-prompting (Bug 1), or
+//   - the subject degrades to '' and `x.startsWith('')` matches EVERY command,
+//     whitelisting all shell commands (Bug 2, a security hole).
+//
+// SCOPE: applies ONLY to the `command` field of Bash-like tools. path / url /
+// pattern subjects MUST keep their full prefix and are handled by the caller
+// (see permissionRuleStore.extractSubject field priority).
+/**
+ * Raw agent tool names whose input carries a `command` field. These are the
+ * ORIGINAL agent-emitted names (NOT normalized): Claude `Bash`, OpenCode/Hermes/
+ * OpenClaw `execute`, Codex `shell`. The permission-request event and the danger
+ * detector both see raw names, so this set is matched against raw names.
+ */
+export const BASH_TOOL_NAMES = new Set(['Bash', 'bash', 'execute', 'shell']);
+/** True when `toolName` (a raw agent name) is a Bash-like command tool. */
+export function isBashToolName(toolName) {
+    return BASH_TOOL_NAMES.has(toolName);
+}
+/**
+ * Extract the prefix subject from a Bash-like command string:
+ *   trim → first token (quote-aware so `"C:\Program Files\..."` isn't split on
+ *   spaces) → basename (`.../pwsh.exe` → `pwsh.exe`).
+ *
+ * Returns '' ONLY for an empty/blank command. When the first token ends in a
+ * path separator its basename is empty; we fall back to the un-split token
+ * rather than '' — an empty subject makes every command match
+ * (`x.startsWith('')` is always true), the Bug 2 security hole.
+ */
+export function extractCommandSubject(command) {
+    const trimmed = command.trim();
+    if (!trimmed)
+        return '';
+    let firstToken;
+    if (trimmed[0] === '"' || trimmed[0] === "'") {
+        const quote = trimmed[0];
+        const end = trimmed.indexOf(quote, 1);
+        firstToken = end > 0 ? trimmed.slice(1, end) : trimmed.slice(1);
+    }
+    else {
+        firstToken = trimmed.split(/\s+/)[0] ?? trimmed;
+    }
+    // Basename: "C:\...\pwsh.exe" → "pwsh.exe". A trailing separator yields ''
+    // from .pop(); '' is not nullish so '??' won't catch it — guard on truthiness
+    // and fall back to the full token so the subject never degrades to '' (Bug 2).
+    const base = firstToken.split(/[/\\]/).pop();
+    const clean = base ? base : firstToken;
+    // Strip quotes that survived token extraction — shell variable assignments
+    // like FILE="/path/to/tool" leave a trailing/leading quote in the basename.
+    return clean.replace(/^["']|["']$/g, '');
+}
+/**
+ * Minimum length for a command subject to be used in a prefix rule.
+ * Single-char subjects (e.g. `#` from a comment line, `.` from a dotfile)
+ * are too broad — they effectively wildcard-match every command that starts
+ * with that character.
+ *
+ * Used by the front-end to reject overly broad rules before they are stored.
+ */
+export const MIN_SUBJECT_LENGTH = 2;
+//# sourceMappingURL=permissionSubject.js.map

package/dist/permissionSubject.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"permissionSubject.js","sourceRoot":"","sources":["../src/permissionSubject.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,mFAAmF;AACnF,+DAA+D;AAC/D,EAAE;AACF,4EAA4E;AAC5E,iFAAiF;AACjF,yEAAyE;AACzE,gFAAgF;AAChF,qDAAqD;AACrD,+EAA+E;AAC/E,gEAAgE;AAChE,EAAE;AACF,8EAA8E;AAC9E,6EAA6E;AAC7E,2DAA2D;AAE3D;;;;;GAKG;AACH,MAAM,CAAC,MAAM,eAAe,GAAwB,IAAI,GAAG,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC,CAAC;AAElG,2EAA2E;AAC3E,MAAM,UAAU,cAAc,CAAC,QAAgB;IAC7C,OAAO,eAAe,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;AACvC,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,qBAAqB,CAAC,OAAe;IACnD,MAAM,OAAO,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;IAC/B,IAAI,CAAC,OAAO;QAAE,OAAO,EAAE,CAAC;IAExB,IAAI,UAAkB,CAAC;IACvB,IAAI,OAAO,CAAC,CAAC,CAAC,KAAK,GAAG,IAAI,OAAO,CAAC,CAAC,CAAC,KAAK,GAAG,EAAE,CAAC;QAC7C,MAAM,KAAK,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;QACzB,MAAM,GAAG,GAAG,OAAO,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;QACtC,UAAU,GAAG,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAClE,CAAC;SAAM,CAAC;QACN,UAAU,GAAG,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,OAAO,CAAC;IAClD,CAAC;IAED,2EAA2E;IAC3E,8EAA8E;IAC9E,+EAA+E;IAC/E,MAAM,IAAI,GAAG,UAAU,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,CAAC;IAC7C,MAAM,KAAK,GAAG,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,UAAU,CAAC;IACvC,2EAA2E;IAC3E,4EAA4E;IAC5E,OAAO,KAAK,CAAC,OAAO,CAAC,cAAc,EAAE,EAAE,CAAC,CAAC;AAC3C,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAC"}

package/dist/protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../src/protocol.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,IAAI,CAAC"}

package/dist/protocol.js

@@ -1 +1,7 @@
-"use strict";export const PROTOCOL_VERSION=1;
+/**
+ * Wire protocol version.
+ * Increment ONLY on breaking schema changes (new enum values, renamed events, required fields).
+ * See RFC-021 for the full versioning strategy.
+ */
+export const PROTOCOL_VERSION = 1;
+//# sourceMappingURL=protocol.js.map

package/dist/protocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.js","sourceRoot":"","sources":["../src/protocol.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,CAAC"}

package/dist/rpc.d.ts.map

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

package/dist/rpc.js

@@ -1 +1,269 @@
-"use strict";import{z as t}from"zod";import{SessionMessageSchema as e}from"./messages.js";import{CLI_AGENT_TYPES as n,SPAWNABLE_AGENTS as s}from"./messageMeta.js";import{PermissionModeSchema as i}from"./interactionEvents.js";export const RpcMethod=t.enum(["spawn-session","stop-session","list-sessions","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","get-labs-settings","set-labs-settings","set-auto-upgrade-daemon","check-path","backfill-history-session","trigger-upgrade","checkpoint-list","checkpoint-diff","checkpoint-rollback","refresh-enterprise-models","cancel-task","file-relay-receive","set-debug","get-debug","record-usage","update-agent-models","update-agent-modes"]),SESSION_RPC_METHODS=["answer-question","approve-permission","deny-permission","abort","stop-session","cancel-task"],MACHINE_RPC_METHODS=["start-invite","get-machine-info","get-agent-settings","set-agent-settings","get-labs-settings","set-labs-settings","set-auto-upgrade-daemon","check-path","backfill-history-session","trigger-upgrade","checkpoint-list","checkpoint-diff","checkpoint-rollback","refresh-enterprise-models"],DAEMON_REQUIRED_RPC_METHODS=[...SESSION_RPC_METHODS,...MACHINE_RPC_METHODS],RpcCallSchema=t.object({method:t.string().min(1),params:t.unknown(),timeout:t.number().int().positive().default(3e4)}),RpcResultSchema=t.discriminatedUnion("ok",[t.object({ok:t.literal(!0),result:t.unknown()}),t.object({ok:t.literal(!1),error:t.string()})]),SpawnSessionParamsSchema=t.object({agentType:t.enum(n),cwd:t.string().min(1),prompt:t.string().optional(),permissionMode:i.default("default"),env:t.record(t.string()).optional(),model:t.string().optional(),baseUrl:t.string().url().optional(),appendSystemPrompt:t.string().optional(),allowedTools:t.array(t.string()).optional(),disallowedTools:t.array(t.string()).optional(),mcpConfig:t.string().optional(),resumeSessionId:t.string().optional(),serverSessionId:t.string().optional(),maxTurns:t.number().int().positive().optional(),machineId:t.string().min(1).optional(),spawnToken:t.string().optional(),systemPrompt:t.string().optional(),systemPromptFile:t.string().optional(),appendSystemPromptFile:t.string().optional(),fallbackModel:t.string().optional(),maxBudgetUsd:t.number().positive().optional(),tools:t.array(t.string()).optional(),effort:t.enum(["low","medium","high","xhigh","max"]).optional(),addDirs:t.array(t.string()).optional(),agent:t.string().optional(),agents:t.string().optional(),jsonSchema:t.string().optional(),strictMcpConfig:t.boolean().optional(),chrome:t.boolean().optional(),worktree:t.union([t.boolean(),t.string()]).optional(),forkSession:t.boolean().optional(),sessionId:t.string().uuid().optional(),settings:t.string().optional(),betas:t.array(t.string()).optional(),brief:t.boolean().optional(),noSessionPersistence:t.boolean().optional(),includePartialMessages:t.boolean().optional(),replayUserMessages:t.boolean().optional(),settingSources:t.string().optional(),disableSlashCommands:t.boolean().optional(),files:t.array(t.string()).optional(),pluginDirs:t.array(t.string()).optional(),dangerouslySkipPermissions:t.boolean().optional(),allowDangerouslySkipPermissions:t.boolean().optional(),startupScripts:t.array(t.string()).optional(),source:t.enum(["managed","history","scheduled"]).default("managed"),background:t.boolean().default(!1),useWindowsTerminal:t.boolean().optional()}),GetMessagesParamsSchema=t.object({sessionId:t.string().min(1),fromSeq:t.number().int().nonnegative().optional(),limit:t.number().int().positive().default(100)}),GetMessagesResponseSchema=t.object({messages:t.array(e),total:t.number(),hasMore:t.boolean()}),CustomModelSchema=t.object({id:t.string().min(1),label:t.string().min(1)}),SkillDefinitionSchema=t.object({name:t.string().min(1),description:t.string(),userInvocable:t.boolean().default(!0),source:t.enum(["project","user"]).default("project"),projectPath:t.string().optional()}),AGENT_ENV_NONE="none",AgentEnvConfigSchema=t.object({httpProxy:t.string().optional(),httpsProxy:t.string().optional(),customEnv:t.record(t.string()).optional(),customModels:t.array(CustomModelSchema).optional()}),AgentSettingsSchema=t.object({defaults:AgentEnvConfigSchema.optional(),startupScripts:t.array(t.string()).optional(),telemetryEnabled:t.boolean().optional()}).merge(t.object(Object.fromEntries(s.map(o=>[o,AgentEnvConfigSchema.optional()])))),MachineInfoResponseSchema=t.object({homedir:t.string(),defaultCwd:t.string().optional(),recentCwds:t.array(t.string()),projectPaths:t.array(t.string()).optional().default([]),availableAgents:t.array(t.string()),agentModels:t.record(t.string(),t.array(t.object({id:t.string(),displayName:t.string(),isDefault:t.boolean(),hidden:t.boolean(),source:t.enum(["builtin","acp","env","custom"]).optional().default("acp")}))).optional(),agentModes:t.record(t.string(),t.array(t.object({id:t.string(),label:t.string()}))).optional(),agentCliPaths:t.record(t.string(),t.string()).optional(),agentSettings:AgentSettingsSchema.optional(),agentSkills:t.record(t.string(),t.array(SkillDefinitionSchema)).optional()}),CheckPathParamsSchema=t.object({cwd:t.string().min(1),machineId:t.string().min(1).optional()}),LabsSettingsSchema=t.object({historySessionSync:t.boolean().default(!1)});
+import { z } from 'zod';
+import { SessionMessageSchema } from './messages.js';
+import { CLI_AGENT_TYPES, SPAWNABLE_AGENTS } from './messageMeta.js';
+import { PermissionModeSchema } from './interactionEvents.js';
+export const RpcMethod = z.enum([
+    'spawn-session',
+    'stop-session',
+    'list-sessions',
+    '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',
+    'get-labs-settings',
+    'set-labs-settings',
+    'set-auto-upgrade-daemon',
+    'check-path',
+    'backfill-history-session',
+    'trigger-upgrade',
+    'checkpoint-list',
+    'checkpoint-diff',
+    'checkpoint-rollback',
+    'refresh-enterprise-models',
+    'cancel-task',
+    'file-relay-receive',
+    'set-debug',
+    'get-debug',
+    'record-usage',
+    'update-agent-models',
+    'update-agent-modes',
+]);
+/**
+ * Session-scoped RPC methods — registered by `agentdock start` (CLI process).
+ * These operate on a specific session and require the CLI to be running.
+ */
+export const SESSION_RPC_METHODS = [
+    'answer-question',
+    'approve-permission',
+    'deny-permission',
+    'abort',
+    'stop-session',
+    'cancel-task',
+];
+/**
+ * Machine-scoped RPC methods — registered by the persistent daemon only.
+ * These are account/machine-level operations independent of any session.
+ */
+export const MACHINE_RPC_METHODS = [
+    'start-invite',
+    'get-machine-info',
+    'get-agent-settings',
+    'set-agent-settings',
+    'get-labs-settings',
+    'set-labs-settings',
+    'set-auto-upgrade-daemon',
+    'check-path',
+    'backfill-history-session',
+    'trigger-upgrade',
+    'checkpoint-list',
+    'checkpoint-diff',
+    'checkpoint-rollback',
+    'refresh-enterprise-models',
+];
+/**
+ * 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 const DAEMON_REQUIRED_RPC_METHODS = [
+    ...SESSION_RPC_METHODS,
+    ...MACHINE_RPC_METHODS,
+];
+export const RpcCallSchema = z.object({
+    method: z.string().min(1),
+    params: z.unknown(),
+    timeout: z.number().int().positive().default(30000),
+});
+export const RpcResultSchema = z.discriminatedUnion('ok', [
+    z.object({ ok: z.literal(true), result: z.unknown() }),
+    z.object({ ok: z.literal(false), error: z.string() }),
+]);
+export const SpawnSessionParamsSchema = z.object({
+    agentType: z.enum(CLI_AGENT_TYPES),
+    cwd: z.string().min(1),
+    prompt: z.string().optional(),
+    permissionMode: PermissionModeSchema.default('default'),
+    env: z.record(z.string()).optional(),
+    model: z.string().optional(),
+    baseUrl: z.string().url().optional(),
+    /** System prompt text appended to the agent's built-in system prompt. */
+    appendSystemPrompt: z.string().optional(),
+    /** Restrict agent to only these tools (Claude CLI --allowedTools). */
+    allowedTools: z.array(z.string()).optional(),
+    /** Deny agent from using these tools (Claude CLI --disallowedTools). */
+    disallowedTools: z.array(z.string()).optional(),
+    /** MCP server config JSON string (Claude CLI --mcp-config). */
+    mcpConfig: z.string().optional(),
+    /** Resume a previous session by ID (Claude CLI --resume). */
+    resumeSessionId: z.string().optional(),
+    /** Server session ID to reuse (skip creating new session on resume). */
+    serverSessionId: z.string().optional(),
+    /** Maximum conversation turns before auto-stop (Claude CLI --max-turns). */
+    maxTurns: z.number().int().positive().optional(),
+    /** Target machine for multi-host routing. Omit for single-machine (auto-select). */
+    machineId: z.string().min(1).optional(),
+    /**
+     * Client-generated correlation id for matching the spawned session back to
+     * the originating spawn call. Written into session metadata and echoed in the
+     * update-session broadcast so the web client can identify which new session is
+     * its own (instead of guessing by cwd+machineId, which collides). New-session
+     * flow only — resume passes serverSessionId instead.
+     */
+    spawnToken: z.string().optional(),
+    // ── Claude CLI extended parameters ──────────────────────────────────
+    /** Replace the default system prompt entirely (Claude CLI --system-prompt). */
+    systemPrompt: z.string().optional(),
+    /** Load system prompt from a file path (Claude CLI --system-prompt-file). */
+    systemPromptFile: z.string().optional(),
+    /** Load append system prompt from a file path (Claude CLI --append-system-prompt-file). */
+    appendSystemPromptFile: z.string().optional(),
+    /** Fallback model when primary is overloaded (Claude CLI --fallback-model). */
+    fallbackModel: z.string().optional(),
+    /** Maximum dollar amount for API calls (Claude CLI --max-budget-usd). */
+    maxBudgetUsd: z.number().positive().optional(),
+    /** Specify available tools from the built-in set (Claude CLI --tools). */
+    tools: z.array(z.string()).optional(),
+    /** Reasoning effort level (Claude CLI --effort). */
+    effort: z.enum(['low', 'medium', 'high', 'xhigh', 'max']).optional(),
+    /** Additional directories to allow tool access to (Claude CLI --add-dir). */
+    addDirs: z.array(z.string()).optional(),
+    /** Agent for the session (Claude CLI --agent). */
+    agent: z.string().optional(),
+    /** JSON object defining custom agents (Claude CLI --agents). */
+    agents: z.string().optional(),
+    /** JSON Schema for structured output validation (Claude CLI --json-schema). */
+    jsonSchema: z.string().optional(),
+    /** Only use MCP servers from --mcp-config (Claude CLI --strict-mcp-config). */
+    strictMcpConfig: z.boolean().optional(),
+    /** Enable Chrome integration (Claude CLI --chrome / --no-chrome). */
+    chrome: z.boolean().optional(),
+    /** Create a git worktree for the session (Claude CLI --worktree). */
+    worktree: z.union([z.boolean(), z.string()]).optional(),
+    /** Create a new session ID when resuming (Claude CLI --fork-session). */
+    forkSession: z.boolean().optional(),
+    /** Use a specific session UUID (Claude CLI --session-id). */
+    sessionId: z.string().uuid().optional(),
+    /** Path to settings file or JSON string (Claude CLI --settings). */
+    settings: z.string().optional(),
+    /** Beta headers for API requests (Claude CLI --betas). */
+    betas: z.array(z.string()).optional(),
+    /** Enable brief mode with SendUserMessage tool (Claude CLI --brief). */
+    brief: z.boolean().optional(),
+    /** Disable session persistence (Claude CLI --no-session-persistence). */
+    noSessionPersistence: z.boolean().optional(),
+    /** Include partial message chunks (Claude CLI --include-partial-messages). */
+    includePartialMessages: z.boolean().optional(),
+    /** Re-emit user messages for acknowledgment (Claude CLI --replay-user-messages). */
+    replayUserMessages: z.boolean().optional(),
+    /** Comma-separated setting sources (Claude CLI --setting-sources). */
+    settingSources: z.string().optional(),
+    /** Disable all skills/slash commands (Claude CLI --disable-slash-commands). */
+    disableSlashCommands: z.boolean().optional(),
+    /** File resources to download at startup (Claude CLI --file). */
+    files: z.array(z.string()).optional(),
+    /** Load plugins from directories (Claude CLI --plugin-dir). */
+    pluginDirs: z.array(z.string()).optional(),
+    /** Bypass all permission checks (Claude CLI --dangerously-skip-permissions). */
+    dangerouslySkipPermissions: z.boolean().optional(),
+    /** Enable bypass option without auto-enabling (Claude CLI --allow-dangerously-skip-permissions). */
+    allowDangerouslySkipPermissions: z.boolean().optional(),
+    /** Shell commands to execute before agent starts (same shell, && chained). */
+    startupScripts: z.array(z.string()).optional(),
+    /** Session source — 'managed' (default), 'history' (scanner), 'scheduled' (cron). */
+    source: z.enum(['managed', 'history', 'scheduled']).default('managed'),
+    /** Run in background without a terminal window. Used by scheduled tasks. */
+    background: z.boolean().default(false),
+    /** Use Windows Terminal new-tab instead of cmd /c start (Windows only). */
+    useWindowsTerminal: z.boolean().optional(),
+});
+// ── Get Messages (session history sync) ─────────────────────────────
+export const GetMessagesParamsSchema = z.object({
+    sessionId: z.string().min(1),
+    fromSeq: z.number().int().nonnegative().optional(),
+    limit: z.number().int().positive().default(100),
+});
+export const GetMessagesResponseSchema = z.object({
+    messages: z.array(SessionMessageSchema),
+    total: z.number(),
+    hasMore: z.boolean(),
+});
+// ── Custom Model (user-defined) ─────────────────────────────────────
+export const CustomModelSchema = z.object({
+    id: z.string().min(1),
+    label: z.string().min(1),
+});
+// ── Skill Definition (Provider Skills) ──────────────────────────────
+export const SkillDefinitionSchema = z.object({
+    name: z.string().min(1),
+    description: z.string(),
+    /** If false, the skill is internal-only and should not appear in the menu. */
+    userInvocable: z.boolean().default(true),
+    /** Source: 'project' (.claude/skills/) or 'user' (~/.claude/skills/). */
+    source: z.enum(['project', 'user']).default('project'),
+    /** Project root directory for project-level skills. Undefined for user-level skills. */
+    projectPath: z.string().optional(),
+});
+// ── Agent Settings (proxy + env per agent) ──────────────────────────
+export const AGENT_ENV_NONE = 'none';
+export const AgentEnvConfigSchema = z.object({
+    httpProxy: z.string().optional(),
+    httpsProxy: z.string().optional(),
+    customEnv: z.record(z.string()).optional(),
+    customModels: z.array(CustomModelSchema).optional(),
+});
+export const AgentSettingsSchema = z
+    .object({
+    defaults: AgentEnvConfigSchema.optional(),
+    startupScripts: z.array(z.string()).optional(),
+    telemetryEnabled: z.boolean().optional(),
+})
+    .merge(z.object(Object.fromEntries(SPAWNABLE_AGENTS.map((a) => [a, AgentEnvConfigSchema.optional()]))));
+// ── Get Machine Info (daemon environment) ───────────────────────────
+export const MachineInfoResponseSchema = z.object({
+    homedir: z.string(),
+    defaultCwd: z.string().optional(),
+    recentCwds: z.array(z.string()),
+    /** All known project directories from ~/.claude/projects/ scan. */
+    projectPaths: z.array(z.string()).optional().default([]),
+    availableAgents: z.array(z.string()),
+    agentModels: z
+        .record(z.string(), z.array(z.object({
+        id: z.string(),
+        displayName: z.string(),
+        isDefault: z.boolean(),
+        hidden: z.boolean(),
+        source: z.enum(['builtin', 'acp', 'env', 'custom']).optional().default('acp'),
+    })))
+        .optional(),
+    agentModes: z
+        .record(z.string(), z.array(z.object({ id: z.string(), label: z.string() })))
+        .optional(),
+    /** Per-agent CLI binary paths from agent cache (non-private diagnostics). */
+    agentCliPaths: z.record(z.string(), z.string()).optional(),
+    agentSettings: AgentSettingsSchema.optional(),
+    /** Agent skills discovered from filesystem provider directories.
+     *  Keyed by agent type (e.g. 'claude'). */
+    agentSkills: z.record(z.string(), z.array(SkillDefinitionSchema)).optional(),
+});
+// ── Check Path (validate cwd on target machine) ────────────────────
+export const CheckPathParamsSchema = z.object({
+    cwd: z.string().min(1),
+    /** Target machine for multi-host routing. Omit for single-machine (auto-select). */
+    machineId: z.string().min(1).optional(),
+});
+// ── Labs Settings (experimental features) ───────────────────────────
+export const LabsSettingsSchema = z.object({
+    /** Enable discovery and sync of CLI history sessions (experimental). */
+    historySessionSync: z.boolean().default(false),
+});
+//# sourceMappingURL=rpc.js.map