commonswarm 0.1.18 → 0.1.20

package/cswarm.cjs

@@ -13513,7 +13513,7 @@ __export(cli_exports, {
   resolveDetachedCodexExecutable: () => resolveDetachedCodexExecutable
 });
 module.exports = __toCommonJS(cli_exports);
-var import_node_crypto18 = require("node:crypto");
+var import_node_crypto19 = require("node:crypto");
 var import_node_fs7 = require("node:fs");
 var import_promises10 = require("node:fs/promises");
 var import_node_path17 = require("node:path");
@@ -22105,7 +22105,7 @@ registerUpcaster("TaskCreated", 0, (p) => ({ task_id: p.id, slug: p.name }));
 // src/protocol/workspace-commands.ts
 var INVITATION_MAX_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
 var AGENT_TOKEN_DEFAULT_TTL_MS = 60 * 60 * 1e3;
-var AGENT_TOKEN_MAX_TTL_MS = 8 * 60 * 60 * 1e3;
+var AGENT_TOKEN_MAX_TTL_MS = 24 * 60 * 60 * 1e3;
 var RENEWAL_HORIZON_DEFAULT_MS = 30 * 24 * 60 * 60 * 1e3;
 var RENEWAL_HORIZON_MAX_MS = 90 * 24 * 60 * 60 * 1e3;
 
@@ -22380,6 +22380,41 @@ async function raceSignalDeadline(work, deadline, callerAbort) {
   }
   return await Promise.race(arms);
 }
+async function declareAgentModel(target2, request, fetcher = fetch) {
+  const controller = new AbortController();
+  const timer2 = setTimeout(() => controller.abort(), 3e4);
+  const onCallerAbort = () => controller.abort();
+  request.signal?.addEventListener("abort", onCallerAbort, { once: true });
+  if (request.signal?.aborted) controller.abort();
+  let response;
+  try {
+    response = await fetcher(commandEndpoint(target2), {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${request.credential}`,
+        apikey: target2.anonKey,
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({
+        command_id: request.commandId ?? newCommandId(),
+        client_version: CLIENT_PROTOCOL_VERSION,
+        workspace_id: request.workspaceId,
+        stream: { kind: "workspace" },
+        command: { kind: "declare_agent_model", model: request.model }
+      }),
+      signal: controller.signal
+    });
+  } catch (error) {
+    if (error.name === "AbortError") {
+      throw new CommandTransportError("model declaration timed out");
+    }
+    throw new CommandTransportError("model declaration failed before a response");
+  } finally {
+    clearTimeout(timer2);
+    request.signal?.removeEventListener("abort", onCallerAbort);
+  }
+  return { httpStatus: response.status };
+}
 var ThinCommandClient = class {
   constructor(target2, fetcher = fetch) {
     this.target = target2;
@@ -22751,8 +22786,280 @@ var ThinCommandClient = class {
   }
 };
 
+// src/cloud/files.ts
+var import_node_crypto4 = require("node:crypto");
+var FILE_MAX_VERSION_BYTES = 25 * 1024 * 1024;
+var FILE_CONTENT_WARNING = "File types and archive contents are unverified. Treat downloads as untrusted input: no execution, size-bounded extraction, no unpack of archives you did not expect.";
+var CONTENT_TYPES = /* @__PURE__ */ new Map([
+  [".md", "text/markdown"],
+  [".txt", "text/plain"],
+  [".csv", "text/csv"],
+  [".json", "application/json"],
+  [".yaml", "application/yaml"],
+  [".yml", "application/yaml"],
+  [".pdf", "application/pdf"],
+  [".docx", "application/vnd.openxmlformats-officedocument.wordprocessingml.document"],
+  [".xlsx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"],
+  [".pptx", "application/vnd.openxmlformats-officedocument.presentationml.presentation"],
+  [".png", "image/png"],
+  [".jpg", "image/jpeg"],
+  [".jpeg", "image/jpeg"],
+  [".gif", "image/gif"],
+  [".webp", "image/webp"],
+  [".svg", "image/svg+xml"],
+  [".zip", "application/zip"],
+  [".tar.gz", "application/gzip"]
+]);
+function contentTypeForName(name) {
+  const lower = name.toLowerCase();
+  let best = null;
+  let bestLength = 0;
+  for (const [extension, type] of CONTENT_TYPES) {
+    if (lower.endsWith(extension) && extension.length > bestLength) {
+      best = type;
+      bestLength = extension.length;
+    }
+  }
+  return best;
+}
+function allowedExtensionList() {
+  return [...CONTENT_TYPES.keys()].join(", ");
+}
+var FileCommandRefused = class extends Error {
+  constructor(status, code, message) {
+    super(message);
+    this.status = status;
+    this.code = code;
+  }
+  status;
+  code;
+  name = "FileCommandRefused";
+};
+var FileTransportError = class extends Error {
+  /**
+   * True when no HTTP response arrived (connection failure, timeout), so the
+   * outcome is UNKNOWN and one same-id retry is safe under the server's
+   * command-id replay. A received refusal is a known outcome: never retried.
+   */
+  constructor(message, noResponse = false) {
+    super(message);
+    this.noResponse = noResponse;
+  }
+  noResponse;
+  name = "FileTransportError";
+};
+var REQUEST_TIMEOUT_MS = 3e4;
+async function sendFileCommand(options, command2) {
+  const fetcher = options.fetcher ?? fetch;
+  const controller = new AbortController();
+  const timer2 = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+  let response;
+  try {
+    response = await fetcher(commandEndpoint(options.target), {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${options.credential}`,
+        apikey: options.target.anonKey,
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({
+        command_id: options.commandId ?? newCommandId(),
+        client_version: "0.1.0",
+        workspace_id: options.workspaceId,
+        stream: { kind: "workspace" },
+        command: command2
+      }),
+      signal: controller.signal
+    });
+  } catch (error) {
+    if (error.name === "AbortError") {
+      throw new FileTransportError("file command timed out", true);
+    }
+    throw new FileTransportError("file command failed before a response", true);
+  } finally {
+    clearTimeout(timer2);
+  }
+  const body = await response.json().catch(() => null);
+  if (!response.ok) {
+    const code = typeof body?.error === "string" ? body.error : "http_error";
+    const message = typeof body?.message === "string" ? body.message : `file command failed (HTTP ${response.status})`;
+    throw new FileCommandRefused(response.status, code, message);
+  }
+  if (!body || typeof body !== "object") {
+    throw new FileTransportError("file command returned a malformed response");
+  }
+  return body;
+}
+function fileVersionCreate(options, input) {
+  return sendFileCommand(options, {
+    kind: "file_version_create",
+    file_id: input.fileId,
+    version_id: input.versionId,
+    name: input.name,
+    declared_size_bytes: input.declaredSizeBytes,
+    content_type: input.contentType
+  });
+}
+function fileVersionCommit(options, input) {
+  return sendFileCommand(options, {
+    kind: "file_version_commit",
+    file_id: input.fileId,
+    version_id: input.versionId,
+    sha256: input.sha256
+  });
+}
+function fileDownloadUrl(options, input) {
+  return sendFileCommand(options, {
+    kind: "file_download_url",
+    file_id: input.fileId,
+    version_n: input.versionN
+  });
+}
+function fileTombstone(options, input) {
+  return sendFileCommand(options, {
+    kind: "file_tombstone",
+    file_id: input.fileId
+  });
+}
+function fileRestore(options, input) {
+  return sendFileCommand(options, {
+    kind: "file_restore",
+    file_id: input.fileId
+  });
+}
+function absoluteStorageUrl(target2, path) {
+  if (!path.startsWith("/")) {
+    throw new FileTransportError(
+      "the server returned a storage path that is not relative; refusing to compose a URL from it"
+    );
+  }
+  return `${target2.url}${path}`;
+}
+async function putObject(target2, uploadPath, bytes, contentType, fetcher = fetch) {
+  let response;
+  try {
+    response = await fetcher(absoluteStorageUrl(target2, uploadPath), {
+      method: "PUT",
+      headers: { "content-type": contentType },
+      /* Node's Buffer types as Uint8Array<ArrayBufferLike>, which the DOM-lib
+       * BodyInit rejects since TS 5.7; the runtime accepts it. */
+      body: bytes
+    });
+  } catch {
+    throw new FileTransportError("the upload PUT failed before a response", true);
+  }
+  if (!response.ok) {
+    throw new FileTransportError(
+      `the upload PUT was refused (HTTP ${response.status}). Nothing went live, and this attempt's pending slot expires on its own within three hours. Check cswarm file ls, then re-run cswarm file put \u2014 a re-run is a new upload attempt with fresh ids`
+    );
+  }
+}
+async function onceRetried(step) {
+  try {
+    return await step();
+  } catch (error) {
+    if (error instanceof FileTransportError && error.noResponse) {
+      return await step();
+    }
+    throw error;
+  }
+}
+async function getObject(target2, downloadPath, fetcher = fetch) {
+  let response;
+  try {
+    response = await fetcher(absoluteStorageUrl(target2, downloadPath));
+  } catch {
+    throw new FileTransportError("the download failed before a response");
+  }
+  if (!response.ok) {
+    throw new FileTransportError(
+      `the download was refused (HTTP ${response.status}); the signed URL lasts five minutes \u2014 request a fresh one with cswarm file get`
+    );
+  }
+  return new Uint8Array(await response.arrayBuffer());
+}
+var LocalFileExists = class extends Error {
+  name = "LocalFileExists";
+};
+function writeDestination(destination, bytes, force, writer) {
+  try {
+    writer(destination, bytes, { flag: force ? "w" : "wx" });
+  } catch (error) {
+    if (error.code === "EEXIST") {
+      throw new LocalFileExists(
+        `${destination} already exists locally; nothing was written. Pass --force to overwrite it, or --out <path> to write elsewhere`
+      );
+    }
+    throw error;
+  }
+}
+function sha256Hex(bytes) {
+  return (0, import_node_crypto4.createHash)("sha256").update(bytes).digest("hex");
+}
+async function listFilesAsAgent(target2, credential, workspaceId2, fetcher = fetch) {
+  let response;
+  try {
+    response = await fetcher(readEndpoint(target2), {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${credential}`,
+        apikey: target2.anonKey,
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({ resource: "files", workspace_id: workspaceId2 })
+    });
+  } catch {
+    throw new FileTransportError("file list could not reach the cloud service");
+  }
+  if (!response.ok) {
+    throw new FileCommandRefused(
+      response.status,
+      "http_error",
+      `file list failed (HTTP ${response.status})`
+    );
+  }
+  const body = await response.json().catch(() => null);
+  if (!body || !Array.isArray(body.files)) {
+    throw new FileTransportError("file list returned a malformed response");
+  }
+  return body.files;
+}
+async function listFilesAsHuman(target2, accessToken, workspaceId2, fetcher = fetch) {
+  const url = new URL("/rest/v1/files", target2.url);
+  url.searchParams.set("workspace_id", `eq.${workspaceId2}`);
+  url.searchParams.set(
+    "select",
+    "file_id,name,current_version,size_bytes,content_type,sha256,created_by_kind,created_by,uploaded_by_kind,uploaded_by,created_at,committed_at,tombstoned_at"
+  );
+  url.searchParams.set("order", "name.asc");
+  let response;
+  try {
+    response = await fetcher(url, {
+      headers: {
+        authorization: `Bearer ${accessToken}`,
+        apikey: target2.anonKey,
+        "accept-profile": "swarm_read"
+      }
+    });
+  } catch {
+    throw new FileTransportError("file list could not reach the cloud service");
+  }
+  if (!response.ok) {
+    throw new FileCommandRefused(
+      response.status,
+      "http_error",
+      `file list failed (HTTP ${response.status})`
+    );
+  }
+  const body = await response.json().catch(() => null);
+  if (!Array.isArray(body)) {
+    throw new FileTransportError("file list returned a malformed response");
+  }
+  return body;
+}
+
 // src/cloud/current-target.ts
-var import_node_crypto5 = require("node:crypto");
+var import_node_crypto6 = require("node:crypto");
 var import_promises3 = require("node:fs/promises");
 var import_node_path2 = require("node:path");
 
@@ -22761,7 +23068,7 @@ var import_node_fs = require("node:fs");
 var import_promises = require("node:fs/promises");
 var import_node_os = require("node:os");
 var import_node_path = require("node:path");
-var import_node_crypto4 = require("node:crypto");
+var import_node_crypto5 = require("node:crypto");
 var import_node_child_process2 = require("node:child_process");
 var import_promises2 = require("node:timers/promises");
 var KEYCHAIN_SERVICE = "com.commonswarm.cli";
@@ -22924,7 +23231,7 @@ async function withFileLock(stateDirectory2, lockName, work) {
       if (Date.now() >= deadline) {
         throw new Error("timed out waiting for the credential refresh lock");
       }
-      await (0, import_promises2.setTimeout)(25 + (0, import_node_crypto4.randomBytes)(1)[0] % 75);
+      await (0, import_promises2.setTimeout)(25 + (0, import_node_crypto5.randomBytes)(1)[0] % 75);
     }
   }
   try {
@@ -22941,7 +23248,7 @@ async function writeSecureJsonFile(path, serialized) {
   } catch (error) {
     if (error.code !== "ENOENT") throw error;
   }
-  const temporary = `${path}.${process.pid}.${(0, import_node_crypto4.randomBytes)(6).toString("hex")}.tmp`;
+  const temporary = `${path}.${process.pid}.${(0, import_node_crypto5.randomBytes)(6).toString("hex")}.tmp`;
   const handle = await (0, import_promises.open)(temporary, "wx", 384);
   try {
     await handle.writeFile(serialized, "utf8");
@@ -23291,7 +23598,7 @@ async function writeCurrentTarget(target2, options = {}) {
     anonKey: validated.anonKey
   };
   const serialized = JSON.stringify(record);
-  const temporary = `${path}.${process.pid}.${(0, import_node_crypto5.randomBytes)(6).toString("hex")}.tmp`;
+  const temporary = `${path}.${process.pid}.${(0, import_node_crypto6.randomBytes)(6).toString("hex")}.tmp`;
   const handle = await (0, import_promises3.open)(temporary, "wx", 384);
   try {
     await handle.writeFile(serialized, "utf8");
@@ -23319,7 +23626,7 @@ async function clearCurrentTarget(options = {}) {
   }
 }
 function targetFingerprint(target2) {
-  return (0, import_node_crypto5.createHash)("sha256").update(target2.anonKey).digest("hex").slice(0, 12);
+  return (0, import_node_crypto6.createHash)("sha256").update(target2.anonKey).digest("hex").slice(0, 12);
 }
 function currentTargetSummary(target2, reveal = false) {
   return {
@@ -23414,7 +23721,7 @@ async function resolveCloudTarget(options) {
 }
 
 // src/cloud/seed.ts
-var import_node_crypto6 = require("node:crypto");
+var import_node_crypto7 = require("node:crypto");
 
 // node_modules/postgres/src/index.js
 var import_os = __toESM(require("os"), 1);
@@ -25552,7 +25859,7 @@ var P0_SCOPES = [
   "post_signal"
 ];
 function deterministicUuid(label) {
-  const bytes = (0, import_node_crypto6.createHash)("sha256").update(label).digest().subarray(0, 16);
+  const bytes = (0, import_node_crypto7.createHash)("sha256").update(label).digest().subarray(0, 16);
   bytes[6] = bytes[6] & 15 | 80;
   bytes[8] = bytes[8] & 63 | 128;
   const hex = bytes.toString("hex");
@@ -25725,10 +26032,10 @@ async function seedDogfood(options) {
           tokenExpiresAt: existing[0].expires_at.toISOString()
         };
       }
-      const agentToken = `swm_agt_${(0, import_node_crypto6.randomBytes)(32).toString("base64url")}`;
-      const tokenHash = (0, import_node_crypto6.createHash)("sha256").update(agentToken).digest();
-      const tokenId = (0, import_node_crypto6.randomUUID)();
-      const lineageId = (0, import_node_crypto6.randomUUID)();
+      const agentToken = `swm_agt_${(0, import_node_crypto7.randomBytes)(32).toString("base64url")}`;
+      const tokenHash = (0, import_node_crypto7.createHash)("sha256").update(agentToken).digest();
+      const tokenId = (0, import_node_crypto7.randomUUID)();
+      const lineageId = (0, import_node_crypto7.randomUUID)();
       const inserted = await tx`
         INSERT INTO swarm.agent_tokens (
           token_id, principal_id, run_id, task_id, epoch,
@@ -25768,14 +26075,14 @@ async function seedDogfood(options) {
 }
 
 // src/cloud/agent-credential.ts
-var import_node_crypto7 = require("node:crypto");
+var import_node_crypto8 = require("node:crypto");
 var import_node_os2 = require("node:os");
 var import_node_path3 = require("node:path");
 var UUID_RE3 = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 var AGENT_TOKEN_RE2 = /^swm_agt_[A-Za-z0-9_-]{43}$/;
 var MAX_RECORD_BYTES = 4 * 1024;
 function credentialLineageKey(rootToken) {
-  return (0, import_node_crypto7.createHash)("sha256").update(rootToken).digest("hex").slice(0, 32);
+  return (0, import_node_crypto8.createHash)("sha256").update(rootToken).digest("hex").slice(0, 32);
 }
 function defaultAgentCredentialDirectory() {
   const configured = process.env.SWARM_AGENT_STATE_DIR;
@@ -25835,7 +26142,7 @@ async function agentCredentialStore(options) {
 }
 
 // src/cloud/renewal.ts
-var import_node_crypto8 = require("node:crypto");
+var import_node_crypto9 = require("node:crypto");
 var AGENT_TOKEN_DEFAULT_TTL_MS2 = 60 * 60 * 1e3;
 var AGENT_TOKEN_MAX_TTL_MS2 = 8 * 60 * 60 * 1e3;
 var RENEWAL_HORIZON_DEFAULT_MS2 = 30 * 24 * 60 * 60 * 1e3;
@@ -25920,7 +26227,7 @@ function renewalCommand() {
   return command2;
 }
 function newRenewalCommandId() {
-  return `ren_${(0, import_node_crypto8.randomBytes)(18).toString("base64url")}`;
+  return `ren_${(0, import_node_crypto9.randomBytes)(18).toString("base64url")}`;
 }
 function timestamp(value) {
   if (typeof value === "number" && Number.isFinite(value) && value > 0) {
@@ -26406,11 +26713,11 @@ var AgentCredentialSession = class _AgentCredentialSession {
 };
 
 // src/cloud/pending-command.ts
-var import_node_crypto9 = require("node:crypto");
+var import_node_crypto10 = require("node:crypto");
 var MAX_PENDING_COMMANDS2 = 32;
 var SIGNAL_PENDING_RECOVERY_MS = 60 * 60 * 1e3;
 function intentHash(workspace, command2) {
-  return (0, import_node_crypto9.createHash)("sha256").update(canonicalJson({ workspace_id: workspace ?? null, command: command2 })).digest("hex");
+  return (0, import_node_crypto10.createHash)("sha256").update(canonicalJson({ workspace_id: workspace ?? null, command: command2 })).digest("hex");
 }
 async function pendingCommandId(credentials, userId, workspace, command2) {
   const intent = intentHash(workspace, command2);
@@ -26510,7 +26817,7 @@ async function sendCapabilityWithPending(client, session, workspace, command2) {
   }
 }
 function signalIntentHash(workspace, command2, credentialIdentity) {
-  return (0, import_node_crypto9.createHash)("sha256").update(canonicalJson({
+  return (0, import_node_crypto10.createHash)("sha256").update(canonicalJson({
     workspace_id: workspace,
     command: command2,
     credential_identity: credentialIdentity
@@ -26592,7 +26899,7 @@ async function sendSignalWithPending(client, session, workspace, command2) {
 var import_node_os3 = require("node:os");
 
 // src/cloud/invite-link.ts
-var import_node_crypto10 = require("node:crypto");
+var import_node_crypto11 = require("node:crypto");
 var MAX_LINK_PAYLOAD_BYTES = 8 * 1024;
 var MAX_LABEL_INPUT_LENGTH = 1024;
 var CONTROL_GLOBAL_RE = /[\u0000-\u001f\u007f-\u009f\u202a-\u202e\u2066-\u2069]/g;
@@ -26763,7 +27070,7 @@ function equalExact(actual, expected) {
   const paddedRight = Buffer.alloc(length);
   left.copy(paddedLeft);
   right.copy(paddedRight);
-  const equal = (0, import_node_crypto10.timingSafeEqual)(paddedLeft, paddedRight);
+  const equal = (0, import_node_crypto11.timingSafeEqual)(paddedLeft, paddedRight);
   return equal && left.length === right.length;
 }
 async function requirePinnedOrigin(target2, options) {
@@ -29065,7 +29372,7 @@ async function runInboxFollow(options) {
 
 // src/host/opencode.ts
 var import_node_child_process3 = require("node:child_process");
-var import_node_crypto11 = require("node:crypto");
+var import_node_crypto12 = require("node:crypto");
 var import_node_fs3 = require("node:fs");
 var import_promises4 = require("node:fs/promises");
 var import_node_os4 = require("node:os");
@@ -30250,7 +30557,7 @@ function buildOpenCodeHomeOwner(options) {
     version: 1,
     pid: options.pid ?? process.pid,
     uid: uid2,
-    instanceId: options.instanceId ?? (0, import_node_crypto11.randomUUID)(),
+    instanceId: options.instanceId ?? (0, import_node_crypto12.randomUUID)(),
     role: options.role,
     createdAt: new Date((options.now ?? Date.now)()).toISOString()
   };
@@ -31798,7 +32105,7 @@ var ListenerEngine = class {
 };
 
 // src/listener/file-store.ts
-var import_node_crypto12 = require("node:crypto");
+var import_node_crypto13 = require("node:crypto");
 var import_node_os5 = require("node:os");
 var import_node_path8 = require("node:path");
 var import_node_util = require("node:util");
@@ -31845,7 +32152,7 @@ function listenerInstanceKey(input) {
   if (!input.profileId || input.profileId.includes("\0")) {
     throw new Error("listener profile id is invalid");
   }
-  return (0, import_node_crypto12.createHash)("sha256").update(input.profileId).update("\0").update(input.workspaceId.toLowerCase()).update("\0").update(input.principalId.toLowerCase()).digest("hex");
+  return (0, import_node_crypto13.createHash)("sha256").update(input.profileId).update("\0").update(input.workspaceId.toLowerCase()).update("\0").update(input.principalId.toLowerCase()).digest("hex");
 }
 function integer(value) {
   return Number.isSafeInteger(value) && value >= 0;
@@ -32380,7 +32687,7 @@ var GrokListenerModel = class {
 };
 
 // src/listener/opencode-model.ts
-var import_node_crypto13 = require("node:crypto");
+var import_node_crypto14 = require("node:crypto");
 var import_promises6 = require("node:fs/promises");
 var import_node_path11 = require("node:path");
 function asError(error) {
@@ -32406,7 +32713,7 @@ var OpenCodeListenerModel = class {
   prepareWorkerCwd;
   permissionMode;
   pendingOpenWaitMs;
-  instanceId = (0, import_node_crypto13.randomUUID)();
+  instanceId = (0, import_node_crypto14.randomUUID)();
   worker = null;
   workerHome = null;
   /** Worker homes retained after failed close or unsettled open. */
@@ -32810,7 +33117,7 @@ var OpenCodeListenerModel = class {
 };
 
 // src/listener/claude-model.ts
-var import_node_crypto14 = require("node:crypto");
+var import_node_crypto15 = require("node:crypto");
 var import_promises7 = require("node:fs/promises");
 var import_node_os7 = require("node:os");
 var import_node_path12 = require("node:path");
@@ -32950,7 +33257,7 @@ var ClaudeListenerModel = class {
   async enablePromptsAfterClaudeCanary(handle) {
     const sentinelPath = (0, import_node_path12.join)(
       (0, import_node_os7.tmpdir)(),
-      `cswarm-claude-permission-canary-${process.pid}-${(0, import_node_crypto14.randomUUID)()}`
+      `cswarm-claude-permission-canary-${process.pid}-${(0, import_node_crypto15.randomUUID)()}`
     );
     let sentinelCreated = false;
     try {
@@ -32976,7 +33283,7 @@ var ClaudeListenerModel = class {
 };
 
 // src/listener/codex-model.ts
-var import_node_crypto15 = require("node:crypto");
+var import_node_crypto16 = require("node:crypto");
 var import_promises8 = require("node:fs/promises");
 var import_node_os8 = require("node:os");
 var import_node_path13 = require("node:path");
@@ -33116,7 +33423,7 @@ var CodexListenerModel = class {
   async enablePromptsAfterCodexCanary(handle) {
     const sentinelPath = (0, import_node_path13.join)(
       (0, import_node_os8.tmpdir)(),
-      `cswarm-codex-permission-canary-${process.pid}-${(0, import_node_crypto15.randomUUID)()}`
+      `cswarm-codex-permission-canary-${process.pid}-${(0, import_node_crypto16.randomUUID)()}`
     );
     let sentinelCreated = false;
     try {
@@ -33142,7 +33449,7 @@ var CodexListenerModel = class {
 };
 
 // src/listener/runtime.ts
-var import_node_crypto16 = require("node:crypto");
+var import_node_crypto17 = require("node:crypto");
 
 // src/cloud/delivery.ts
 var UUID_RE10 = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
@@ -33873,7 +34180,7 @@ function sameEffectSignal(record, signal) {
   return record.signalId === signal.id.toLowerCase() && record.signalKind === signal.kind && record.askBody === signal.body && record.askUntil === signal.until && record.senderOwnerRelation === (signal.sender_owner_relation ?? "unknown");
 }
 function immutableSignalFingerprint(signalId, signalKind2, body, until, senderOwnerRelation) {
-  return (0, import_node_crypto16.createHash)("sha256").update(JSON.stringify([
+  return (0, import_node_crypto17.createHash)("sha256").update(JSON.stringify([
     signalId,
     signalKind2,
     body,
@@ -34214,6 +34521,30 @@ async function runListenerRuntime(options) {
           principalId: options.principalId,
           ts: eventTime(now)
         });
+        if (options.declareModel !== void 0) {
+          const declaredLabel = options.declareModel;
+          void (async () => {
+            let declared = false;
+            try {
+              const credential = await options.credentialSession.bearer();
+              const outcome = await declareAgentModel(options.target, {
+                workspaceId: options.workspaceId,
+                model: declaredLabel,
+                credential,
+                ...abort ? { signal: abort } : {}
+              }, options.fetcher);
+              declared = outcome.httpStatus === 200;
+            } catch {
+              declared = false;
+            }
+            options.onEvent?.({
+              type: "model_declared",
+              ok: declared,
+              model: declaredLabel,
+              ts: eventTime(now)
+            });
+          })();
+        }
       }
       let currentJournalRecord = null;
       if (durableConfigured) {
@@ -35068,7 +35399,7 @@ async function queryListenerControl(paths, command2, timeoutMs = CONTROL_TIMEOUT
 }
 
 // src/listener/supervisor.ts
-var import_node_crypto17 = require("node:crypto");
+var import_node_crypto18 = require("node:crypto");
 var UUID_RE13 = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 var LISTENER_RESTART_MAX_ATTEMPTS = 5;
 var LISTENER_RESTART_INITIAL_MS = 1e3;
@@ -35116,7 +35447,7 @@ async function runListenerSupervisor(options) {
   const now = options.now ?? Date.now;
   const startedAt = iso2(now);
   const controller = new AbortController();
-  const proposedInstanceId = (0, import_node_crypto17.randomUUID)();
+  const proposedInstanceId = (0, import_node_crypto18.randomUUID)();
   let status = {
     version: 1,
     instanceId: proposedInstanceId,
@@ -35227,6 +35558,15 @@ async function runListenerSupervisor(options) {
       });
       return;
     }
+    if (event.type === "model_declared") {
+      log({
+        ts: event.ts,
+        event: "listener_model_declared",
+        ok: event.ok,
+        model: event.model
+      });
+      return;
+    }
     if (event.type === "delivery_mode") {
       status = {
         ...status,
@@ -36276,12 +36616,14 @@ var KNOWN_FLAGS = /* @__PURE__ */ new Set([
   "epoch",
   "evidence",
   "follow",
+  "force",
   "force-file-store",
   "foreground",
   "grok-executable",
   "head-sha",
   "help",
   "include-stale",
+  "include-tombstoned",
   "invitation-id",
   "invitation-token-stdin",
   "json",
@@ -36294,6 +36636,7 @@ var KNOWN_FLAGS = /* @__PURE__ */ new Set([
   "ndjson",
   "no-browser",
   "opencode-executable",
+  "out",
   "permissions",
   "principal-id",
   "provider",
@@ -36318,9 +36661,11 @@ var BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
   "all-devices",
   "force-file-store",
   "follow",
+  "force",
   "foreground",
   "help",
   "include-stale",
+  "include-tombstoned",
   "invitation-token-stdin",
   "json",
   "link-stdin",
@@ -36337,8 +36682,8 @@ var ACCEPTED_AGENT_CREDENTIAL_MESSAGES = [
   AGENT_CREDENTIAL_MESSAGE_D088
 ];
 function packageVersion() {
-  if ("0.1.18".length > 0) {
-    return "0.1.18";
+  if ("0.1.20".length > 0) {
+    return "0.1.20";
   }
   try {
     const value = JSON.parse(
@@ -36460,6 +36805,11 @@ Usage:
   cswarm feed [--url <url> --anon-key <key>] [--workspace-id <uuid>] [--about <ref>] [--kind <kind>] [--since <timestamp>] [--limit <n>] [--include-stale] [--json]
   cswarm inbox [--url <url> --anon-key <key>] [--workspace-id <uuid>] [--kind <kind>] [--about <ref>] [--since <timestamp>] [--limit <n>] [--include-stale] [--wait <seconds>] [--json]
   cswarm inbox --follow --ndjson [--url <url> --anon-key <key>] [--workspace-id <uuid>] [--kind <kind>] [--about <ref>] [--since <timestamp>] [--limit <n>] [--include-stale]
+  cswarm file put <local-path> [--name <name>] [--url <url> --anon-key <key>] [--workspace-id <uuid>] [--agent-token-stdin] [--json]
+  cswarm file ls [--include-tombstoned] [--url <url> --anon-key <key>] [--workspace-id <uuid>] [--agent-token-stdin] [--json]
+  cswarm file get <name|file-id> [--version <n>] [--out <local-path>] [--force] [--url <url> --anon-key <key>] [--workspace-id <uuid>] [--agent-token-stdin] [--json]
+  cswarm file rm <name|file-id> [--url <url> --anon-key <key>] [--workspace-id <uuid>] [--agent-token-stdin] [--json]
+  cswarm file restore <name|file-id> [--url <url> --anon-key <key>] [--workspace-id <uuid>] [--agent-token-stdin] [--json]
   cswarm listen start --agent-token-stdin [--url <url> --anon-key <key>] --workspace-id <uuid> --provider grok|opencode|claude|codex [--cwd <absolute-path>] [--model <model>] [--effort <level>] [--permissions deny|allow] [--grok-executable <path>] [--opencode-executable <path>] [--claude-executable <path>] [--codex-executable <path>] [--foreground] [--json]
   cswarm listen status [--url <url> --anon-key <key>] --workspace-id <uuid> --principal-id <uuid> [--json]
   cswarm listen stop [--url <url> --anon-key <key>] --workspace-id <uuid> --principal-id <uuid> [--json]
@@ -36493,6 +36843,8 @@ Credential selection for command/dogfood:
                           One that persists or references the credential needs the complete
                           JSON artifact, because it needs a field a bare secret does not carry:
                             members       reads only          -- either form
+                            file put, file ls, file get, file rm, file restore
+                                          read and command, nothing persisted -- either form
                             listen start  persists durable state, rotates -- needs expires_at
                             token revoke  names what it revokes           -- needs token_id
 
@@ -36835,7 +37187,7 @@ async function runNew(args) {
   assertWorkspaceName(name);
   const cloud = await target(args);
   const human = await humanCredential(args, cloud);
-  const proposedId = (0, import_node_crypto18.randomUUID)();
+  const proposedId = (0, import_node_crypto19.randomUUID)();
   let result;
   try {
     result = await new ThinCommandClient(cloud).sendConnect({
@@ -37442,7 +37794,7 @@ async function runToken(args) {
         ...ttl === void 0 ? {} : {
           ttl_ms: integer2(args, "ttl-ms", {
             minimum: 1,
-            maximum: 288e5
+            maximum: 864e5
           })
         }
       }
@@ -38464,6 +38816,18 @@ function listenerStateDirectory(args) {
   }
   return value;
 }
+function listenerModelLabel(provider) {
+  switch (provider) {
+    case "claude":
+      return "claude (claude-agent-acp 0.64.2)";
+    case "codex":
+      return "codex (codex-acp 1.1.9)";
+    case "opencode":
+      return "opencode";
+    case "grok":
+      return "grok";
+  }
+}
 function listenerProvider(args) {
   const provider = args.optional("provider");
   const hints = "supported providers: grok \u2014 install Grok CLI 0.2.117 and run grok login; opencode \u2014 install OpenCode 1.18.10 and authenticate it; claude \u2014 npm install -g @agentclientprotocol/claude-agent-acp@0.64.2; codex \u2014 npm install -g @agentclientprotocol/codex-acp@1.1.9. You can use working-on, note, ask, and feed now; detached live receipt needs one of these adapters";
@@ -38867,6 +39231,7 @@ async function runConfiguredListener(options) {
           model: newModel(),
           signal,
           onEvent,
+          declareModel: listenerModelLabel(options.provider),
           listenerInstanceId,
           deliveryJournal: selectedJournal,
           resolveSenderProvenance
@@ -39123,6 +39488,238 @@ async function runListen(args) {
   }
   throw new UsageError("listen requires start, status, or stop");
 }
+function formatFileSize(value) {
+  const bytes = Number(value ?? 0);
+  if (!Number.isFinite(bytes) || bytes <= 0) return "0 B";
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+async function fileContext(args, extraFlags, positionalCount) {
+  args.assertShape(
+    [...TARGET_FLAGS, "workspace-id", ...CREDENTIAL_FLAGS, "json", ...extraFlags],
+    positionalCount
+  );
+  const cloud = await target(args);
+  const selected = await commandWorkspaceAndCredential(args, cloud, {
+    validateHumanWorkspace: true
+  });
+  return { cloud, selected };
+}
+async function fileRows(context) {
+  const { cloud, selected } = context;
+  if (selected.kind === "agent") {
+    return await listFilesAsAgent(
+      cloud,
+      selected.bearer,
+      selected.selectedWorkspace
+    );
+  }
+  return await listFilesAsHuman(
+    cloud,
+    selected.human.accessToken,
+    selected.selectedWorkspace
+  );
+}
+async function resolveFileSelector(context, selector) {
+  if (UUID_RE15.test(selector)) return selector.toLowerCase();
+  const rows3 = await fileRows(context);
+  const match = rows3.find(
+    (row) => row.name.toLowerCase() === selector.toLowerCase()
+  );
+  if (match === void 0) {
+    throw new Error(
+      `no file named "${sanitizeDisplayLabel(selector, "that name")}" exists in this workspace; run cswarm file ls to see what does, or pass a file id`
+    );
+  }
+  return match.file_id;
+}
+async function runFilePut(args) {
+  const localPath = args.positionals[2];
+  if (!localPath) throw new UsageError("cswarm file put needs a local path");
+  const context = await fileContext(args, ["name"], 3);
+  let bytes;
+  try {
+    bytes = (0, import_node_fs7.readFileSync)(localPath);
+  } catch {
+    throw new Error(`could not read ${localPath}; check the path and permissions`);
+  }
+  const name = args.optional("name") ?? (0, import_node_path17.basename)(localPath);
+  if (bytes.byteLength > FILE_MAX_VERSION_BYTES) {
+    throw new Error(
+      `this file is ${formatFileSize(bytes.byteLength)}; the per-file limit is ${formatFileSize(FILE_MAX_VERSION_BYTES)}, so the upload was not started`
+    );
+  }
+  const contentType = contentTypeForName(name);
+  if (contentType === null) {
+    throw new Error(
+      `"${sanitizeDisplayLabel(name, "that name")}" has no allowed file extension; the workspace accepts ${allowedExtensionList()}`
+    );
+  }
+  const send = {
+    target: context.cloud,
+    workspaceId: context.selected.selectedWorkspace,
+    credential: context.selected.bearer
+  };
+  const fileId = (0, import_node_crypto19.randomUUID)();
+  const versionId = (0, import_node_crypto19.randomUUID)();
+  const createCommandId = newCommandId();
+  const commitCommandId = newCommandId();
+  const created = await onceRetried(
+    () => fileVersionCreate({ ...send, commandId: createCommandId }, {
+      fileId,
+      versionId,
+      name,
+      declaredSizeBytes: bytes.byteLength,
+      contentType
+    })
+  );
+  await onceRetried(
+    () => putObject(context.cloud, created.upload_path, bytes, contentType)
+  );
+  const committed = await onceRetried(
+    () => fileVersionCommit({ ...send, commandId: commitCommandId }, {
+      fileId: created.file_id,
+      versionId: created.version_id,
+      sha256: sha256Hex(bytes)
+    })
+  );
+  if (args.has("json")) {
+    process.stdout.write(`${JSON.stringify(committed, null, 2)}
+`);
+    return;
+  }
+  process.stdout.write(
+    `Uploaded ${committed.name} \u2014 version ${committed.version_n}, ${formatFileSize(committed.size_bytes)}, visible to everyone in this workspace.
+Reference for signals, pinned to this version: --about ${committed.reference}
+The recorded sha256 is an unverified client attestation.
+`
+  );
+}
+async function runFileLs(args) {
+  const context = await fileContext(args, ["include-tombstoned"], 2);
+  const rows3 = await fileRows(context);
+  const visible = args.has("include-tombstoned") ? rows3 : rows3.filter((row) => row.tombstoned_at === null);
+  if (args.has("json")) {
+    process.stdout.write(
+      `${JSON.stringify(
+        {
+          workspace_id: context.selected.selectedWorkspace,
+          files: visible,
+          sha256_note: "unverified client attestation",
+          content_warning: FILE_CONTENT_WARNING
+        },
+        null,
+        2
+      )}
+`
+    );
+    return;
+  }
+  if (visible.length === 0) {
+    process.stdout.write(
+      rows3.length === 0 ? "No files in this workspace yet. Upload one with cswarm file put <path>.\n" : "No live files; tombstoned ones exist. See them with cswarm file ls --include-tombstoned.\n"
+    );
+    return;
+  }
+  process.stdout.write(`Files in this workspace (${visible.length}):
+`);
+  for (const row of visible) {
+    const marker = row.tombstoned_at === null ? "" : "  [tombstoned; restorable with cswarm file restore]";
+    process.stdout.write(
+      `- ${sanitizeDisplayLabel(row.name, "unnamed file")}  v${row.current_version} \xB7 ${formatFileSize(row.size_bytes)} \xB7 ${sanitizeDisplayLabel(row.content_type ?? "unknown type", "unknown type")} \xB7 by ${row.uploaded_by_kind ?? row.created_by_kind}${marker}
+`
+    );
+  }
+  process.stdout.write(`${FILE_CONTENT_WARNING}
+`);
+}
+async function runFileGet(args) {
+  const selector = args.positionals[2];
+  if (!selector) throw new UsageError("cswarm file get needs a file name or id");
+  const context = await fileContext(args, ["version", "out", "force"], 3);
+  const versionN = args.has("version") ? integer2(args, "version", { minimum: 1 }) : null;
+  const fileId = await resolveFileSelector(context, selector);
+  const send = {
+    target: context.cloud,
+    workspaceId: context.selected.selectedWorkspace,
+    credential: context.selected.bearer
+  };
+  const grant = await fileDownloadUrl(send, { fileId, versionN });
+  const destination = args.optional("out") ?? (0, import_node_path17.basename)(grant.name);
+  const bytes = await getObject(context.cloud, grant.download_path);
+  writeDestination(destination, bytes, args.has("force"), import_node_fs7.writeFileSync);
+  if (args.has("json")) {
+    process.stdout.write(
+      `${JSON.stringify(
+        { ...grant, written_to: destination, written_bytes: bytes.byteLength },
+        null,
+        2
+      )}
+`
+    );
+    return;
+  }
+  process.stdout.write(
+    `Downloaded ${grant.name} version ${grant.version_n} (${formatFileSize(bytes.byteLength)}, ${grant.content_type}) to ${destination}.
+${grant.content_warning}
+`
+  );
+}
+async function runFileRm(args) {
+  const selector = args.positionals[2];
+  if (!selector) throw new UsageError("cswarm file rm needs a file name or id");
+  const context = await fileContext(args, [], 3);
+  const fileId = await resolveFileSelector(context, selector);
+  const result = await fileTombstone({
+    target: context.cloud,
+    workspaceId: context.selected.selectedWorkspace,
+    credential: context.selected.bearer
+  }, { fileId });
+  if (args.has("json")) {
+    process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+    return;
+  }
+  process.stdout.write(
+    `Tombstoned ${result.name}. It is hidden from listings and downloads now, and stays restorable with cswarm file restore until ${result.restorable_until ?? "the 30-day window ends"}.
+After that the purge permanently deletes the bytes; existing download URLs expire on their own 5-minute clock.
+`
+  );
+}
+async function runFileRestore(args) {
+  const selector = args.positionals[2];
+  if (!selector) {
+    throw new UsageError("cswarm file restore needs a file name or id");
+  }
+  const context = await fileContext(args, [], 3);
+  const fileId = await resolveFileSelector(context, selector);
+  const result = await fileRestore({
+    target: context.cloud,
+    workspaceId: context.selected.selectedWorkspace,
+    credential: context.selected.bearer
+  }, { fileId });
+  if (args.has("json")) {
+    process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+    return;
+  }
+  process.stdout.write(
+    `Restored ${result.name}. It is listed and downloadable again; nothing else changed.
+`
+  );
+}
+async function runFile(args) {
+  const action = args.positionals[1];
+  if (action === "put") return await runFilePut(args);
+  if (action === "ls") return await runFileLs(args);
+  if (action === "get") return await runFileGet(args);
+  if (action === "rm") return await runFileRm(args);
+  if (action === "restore") return await runFileRestore(args);
+  throw new UsageError(
+    "cswarm file takes put, ls, get, rm, or restore"
+  );
+}
 async function runTaskCommand(args) {
   args.assertShape(
     [...TARGET_FLAGS, ...ROUTE_FLAGS, ...CREDENTIAL_FLAGS, ...TASK_FLAGS],
@@ -39160,7 +39757,7 @@ async function runDogfood(args) {
   const { selectedWorkspace, bearer } = await commandWorkspaceAndCredential(args, cloud);
   const client = new ThinCommandClient(cloud);
   const route = stream(args);
-  const taskId = args.optional("task-id") ?? (0, import_node_crypto18.randomUUID)();
+  const taskId = args.optional("task-id") ?? (0, import_node_crypto19.randomUUID)();
   const ttl = Number(args.optional("ttl-ms") ?? "3600000");
   if (!Number.isSafeInteger(ttl) || ttl <= 0 || ttl > 144e5) {
     throw new Error("--ttl-ms must be an integer in 1..14400000");
@@ -39367,6 +39964,10 @@ async function main() {
     await runStatus(args);
     return;
   }
+  if (verb === "file") {
+    await runFile(args);
+    return;
+  }
   if (verb === "members") {
     await runMembers(args);
     return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "commonswarm",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "description": "CommonSwarm CLI — coordination for teams where people and AI agents work side by side.",
   "bin": {
     "cswarm": "cswarm.cjs"