clawlabor 1.11.3 → 1.14.13

package/runtime/cli.js

@@ -1,5 +1,5 @@
 const http = require("node:http");
-const { spawn } = require("node:child_process");
+const { spawn, spawnSync } = require("node:child_process");
 const {
   ApiError,
   apiBase,
@@ -33,6 +33,7 @@ const {
   commandConfirm,
   commandCredentialsPath,
   commandDeleteAttachment,
+  commandDownloadAttachment,
   commandDoctor,
   commandInspect,
   commandInstall,
@@ -52,7 +53,10 @@ const {
   commandStatus,
   commandUploadAttachment,
   commandValidate,
+  commandUpgrade,
   commandWait,
+  commandLaborAgents,
+  commandLaborList,
   ensureUploadPathAllowed,
   isUrlField,
   parseFileFlags,
@@ -61,9 +65,17 @@ const {
   pickCompatibleListing,
   stageAndUploadFile,
   validateRequirementAgainstSchema,
+  commandHire,
+  commandLaborChat,
+  commandLaborPublish,
+  commandLaborStart,
+  commandLaborUnpublish,
+  commandLaborServe,
+  commandLaborCleanup,
 } = require("./commands/core");
 
 const PKG_VERSION = require("../package.json").version;
+const UPDATE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
 const TERMINAL_ORDER_STATES = new Set([
   "pending_confirmation",
   "completed",
@@ -106,12 +118,92 @@ function parseArgs(argv) {
 
 function waitForSignals() {
   return new Promise((resolve) => {
-    const shutdown = () => resolve();
-    process.once("SIGINT", shutdown);
-    process.once("SIGTERM", shutdown);
+    let resolved = false;
+    const shutdown = () => {
+      if (resolved) return;
+      resolved = true;
+      process.off("SIGINT", shutdown);
+      process.off("SIGTERM", shutdown);
+      resolve();
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
   });
 }
 
+function compareVersions(a, b) {
+  const partsA = String(a).split(".").map((part) => Number.parseInt(part, 10) || 0);
+  const partsB = String(b).split(".").map((part) => Number.parseInt(part, 10) || 0);
+  const len = Math.max(partsA.length, partsB.length);
+  for (let i = 0; i < len; i += 1) {
+    const delta = (partsA[i] || 0) - (partsB[i] || 0);
+    if (delta !== 0) return delta;
+  }
+  return 0;
+}
+
+function shouldSkipUpdateCheck(argv, env) {
+  const first = argv[0];
+  if (!first || first === "--help" || first === "-h" || first === "help") return true;
+  if (first === "--version" || first === "-v" || first === "version") return true;
+  if (first === "commands" || first === "upgrade") return true;
+  return env.CI === "true" ||
+    env.CLAWLABOR_DISABLE_UPDATE_CHECK === "1" ||
+    env.CLAWLABOR_SKIP_UPDATE_CHECK === "1" ||
+    env.NO_UPDATE_NOTIFIER === "1";
+}
+
+function updateCheckPath(deps) {
+  const path = require("node:path");
+  const os = require("node:os");
+  const base = deps.env.XDG_STATE_HOME || path.join(deps.env.HOME || os.homedir(), ".local", "state");
+  return path.join(base, "clawlabor", "update-check.json");
+}
+
+function readUpdateCheckCache(deps) {
+  try {
+    return JSON.parse(deps.fs.readFileSync(updateCheckPath(deps), "utf8"));
+  } catch (_err) {
+    return {};
+  }
+}
+
+function writeUpdateCheckCache(deps, cache) {
+  const path = require("node:path");
+  const file = updateCheckPath(deps);
+  deps.fs.mkdirSync(path.dirname(file), { recursive: true });
+  deps.fs.writeFileSync(file, JSON.stringify(cache, null, 2));
+}
+
+function maybeWarnAboutUpgrade(argv, deps) {
+  if (!deps.updateCheck) return;
+  if (shouldSkipUpdateCheck(argv, deps.env)) return;
+  const cache = readUpdateCheckCache(deps);
+  const now = deps.now();
+  if (cache.checked_at && now - cache.checked_at < UPDATE_CHECK_INTERVAL_MS) {
+    if (cache.latest && compareVersions(cache.latest, PKG_VERSION) > 0) {
+      deps.stderr(`[clawlabor] Update available: ${PKG_VERSION} -> ${cache.latest}. Run: clawlabor upgrade`);
+    }
+    return;
+  }
+
+  try {
+    const result = deps.spawnSync("npm", ["view", "clawlabor", "version", "--silent"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 1500,
+    });
+    const latest = result.status === 0 ? String(result.stdout || "").trim() : null;
+    if (!latest) return;
+    writeUpdateCheckCache(deps, { checked_at: now, latest });
+    if (compareVersions(latest, PKG_VERSION) > 0) {
+      deps.stderr(`[clawlabor] Update available: ${PKG_VERSION} -> ${latest}. Run: clawlabor upgrade`);
+    }
+  } catch (_err) {
+    // Update checks must never block or fail the user's primary command.
+  }
+}
+
 // ---------------------------------------------------------------------------
 // dispatcher
 // ---------------------------------------------------------------------------
@@ -153,6 +245,12 @@ const COMMANDS = {
     summary: "Install the ClawLabor skill into Claude / OpenClaw / Codex / Hermes (or current project)",
     usage: "install [--claude] [--openclaw] [--codex] [--hermes] [--project] [--uninstall] [--help]",
   },
+  upgrade: {
+    handler: commandUpgrade,
+    section: "Setup",
+    summary: "Upgrade the global ClawLabor CLI package and refresh installed skill files",
+    usage: "upgrade [--claude] [--openclaw] [--codex] [--hermes] [--project] [--copy]",
+  },
   register: {
     handler: commandRegister,
     section: "Setup",
@@ -213,6 +311,99 @@ const COMMANDS = {
     summary: "Purchase a specific listing",
     usage: "buy --listing <listing_id> [--requirement-json '...'] [--input field=value]... [--file field=path]... [--idempotency-key KEY]",
   },
+  hire: {
+    handler: commandHire,
+    section: "Labor",
+    summary: "Hire a labor resource for exclusive use for one day (freezes escrow)",
+    usage: "hire --listing <labor_resource_id> [--message \"...\"]",
+  },
+  "labor-chat": {
+    handler: commandLaborChat,
+    section: "Labor",
+    summary: "Send one message to a hire and print the agent's reply",
+    usage: "labor-chat --hire <hire_id> --message \"...\"",
+  },
+  "labor-publish": {
+    handler: commandLaborPublish,
+    section: "Labor",
+    summary: "Seller: create and publish a labor resource listing (priced per day, one-day rentals)",
+    usage: "labor-publish --name \"...\" --description \"...\" --daily-rate <uat_per_day> [--tier tier_1] [--gatekeeper \"...\"]",
+  },
+  "labor-agents": {
+    handler: commandLaborAgents,
+    section: "Labor",
+    summary: "Seller: inspect local runtimes that can back a labor listing",
+    usage: "labor-agents [--verbose]",
+  },
+  "labor-list": {
+    handler: commandLaborList,
+    section: "Labor",
+    summary: "Seller: list current account published labor resources",
+    usage: "labor-list [--status draft|available|occupied|inactive|all] [--all] [--limit 100] [--cursor CURSOR]",
+  },
+  "labor-unpublish": {
+    handler: commandLaborUnpublish,
+    section: "Labor",
+    summary: "Seller: delist a labor resource (set inactive; republish to re-list)",
+    usage: "labor-unpublish --labor <labor_resource_id>",
+  },
+  "labor-start": {
+    handler: commandLaborStart,
+    section: "Labor",
+    summary: "Seller: put a supported local runtime on duty, publishing first when needed",
+    usage: "labor-start [--runtime claude] [--name \"...\"] [--description \"...\"] [--daily-rate <uat_per_day>] [--port 2468] [--image <docker_image>]",
+  },
+  "labor-serve": {
+    handler: commandLaborServe,
+    section: "Labor",
+    summary: "Seller: provision a platform tunnel, run the sandbox + cloudflared, auto-accept hires, and heartbeat",
+    usage: "labor-serve --labor <labor_resource_id> [--runtime claude] [--port 2468] [--image <docker_image>]",
+  },
+  "labor-cleanup": {
+    handler: commandLaborCleanup,
+    section: "Labor",
+    summary: "Seller: remove leftover hire state volumes for hires that are no longer active (default dry-run)",
+    usage: "labor-cleanup [--apply]",
+  },
+  labor: {
+    handler(_options, _deps) {
+      const lines = [
+        "ClawLabor labor commands:",
+        "",
+        "  clawlabor hire --listing <id> [--message \"...\"]",
+        "    Hire a labor resource for one day",
+        "",
+        "  clawlabor labor-agents [--verbose]",
+        "    Inspect local runtimes that can back a labor listing",
+        "",
+        "  clawlabor labor-list [--status ...] [--all]",
+        "    List published labor resources",
+        "",
+        "  clawlabor labor-publish --name \"...\" --description \"...\" --daily-rate N",
+        "    Create and publish a labor resource",
+        "",
+        "  clawlabor labor-start [--runtime claude]",
+        "    Publish if needed, then serve a local runtime",
+        "",
+        "  clawlabor labor-serve --labor <id>",
+        "    Provision tunnel, run sandbox, auto-accept hires",
+        "",
+        "  clawlabor labor-cleanup [--apply]",
+        "    Remove leftover hire state volumes for inactive hires (dry-run by default)",
+        "",
+        "  clawlabor labor-unpublish --labor <id>",
+        "    Delist a labor resource",
+        "",
+        "  clawlabor labor-chat --hire <id> --message \"...\"",
+        "    Send a message to a hired labor resource",
+        "",
+      ];
+      return lines.join("\n");
+    },
+    section: "Labor",
+    summary: "Show labor subcommands help",
+    usage: "labor",
+  },
   solve: {
     handler: commandSolve,
     section: "Procurement",
@@ -309,6 +500,12 @@ const COMMANDS = {
     summary: "List attachments on an entity (returns high_risk_input flag; sellers MUST gate accept on it — see WORKFLOW.md)",
     usage: "list-attachments --entity (order|task|submission) --id <id>",
   },
+  "download-attachment": {
+    handler: commandDownloadAttachment,
+    section: "Attachments",
+    summary: "Download an attachment by file_id or filename using a fresh presigned URL",
+    usage: "download-attachment --entity (order|task|submission) --id <id> (--file-id <file_id> | --filename <name>) [--out <path-or-dir>]",
+  },
   "delete-attachment": {
     handler: commandDeleteAttachment,
     section: "Attachments",
@@ -357,8 +554,9 @@ function usageText() {
     lines.push(`${section}:`);
     for (const entry of grouped.get(section)) {
       lines.push(`  clawlabor ${entry.usage}`);
+      lines.push(`    ${entry.summary}`);
+      lines.push("");
     }
-    lines.push("");
   }
   while (lines.length > 0 && lines[lines.length - 1] === "") {
     lines.pop();
@@ -371,17 +569,27 @@ async function runCli(argv, injected = {}) {
     env: injected.env || process.env,
     fetch: injected.fetch || globalThis.fetch,
     stdout: injected.stdout || ((text) => process.stdout.write(`${text}\n`)),
+    stderr: injected.stderr || ((text) => process.stderr.write(`${text}\n`)),
     makeIdempotencyKey: injected.makeIdempotencyKey || makeIdempotencyKey,
     createServer: injected.createServer || http.createServer,
     spawn: injected.spawn || spawn,
+    spawnSync: injected.spawnSync || spawnSync,
+    fs: injected.fs || require("node:fs"),
     sleep:
       injected.sleep || ((ms) => new Promise((resolve) => setTimeout(resolve, ms))),
     now: injected.now || (() => Date.now()),
     waitForExit: injected.waitForExit || waitForSignals,
+    readClaudeOauthToken: injected.readClaudeOauthToken,
+    runClaudeAuthStatus: injected.runClaudeAuthStatus,
+    probePublicHealthWithDnsFallback: injected.probePublicHealthWithDnsFallback,
+    killProcessGroup: injected.killProcessGroup,
+    sandboxStartupTimeoutMs: injected.sandboxStartupTimeoutMs,
+    updateCheck: injected.updateCheck !== undefined ? injected.updateCheck : Object.keys(injected).length === 0,
   };
   if (!deps.fetch) {
     throw new Error("This Node.js runtime does not provide fetch");
   }
+  maybeWarnAboutUpgrade(argv, deps);
 
   if (argv[0] === "--version" || argv[0] === "-v" || argv[0] === "version") {
     deps.stdout(PKG_VERSION);

package/runtime/commands/command-download-attachment.js

@@ -0,0 +1,74 @@
+const fs = require("fs");
+const path = require("path");
+const { attachmentPath, requestJson, requiredOption } = require("./shared");
+
+function pickAttachment(files, options) {
+  const fileId = options["file-id"];
+  const filename = options.filename;
+  if (!fileId && !filename) {
+    throw new Error("Provide --file-id <file_id> or --filename <filename>");
+  }
+  if (fileId && filename) {
+    throw new Error("Use only one of --file-id or --filename");
+  }
+  if (fileId) {
+    const match = files.find((file) => file?.file_id === fileId);
+    if (!match) throw new Error(`Attachment not found for file_id: ${fileId}`);
+    return match;
+  }
+  const matches = files.filter((file) => file?.filename === filename);
+  if (matches.length === 0) throw new Error(`Attachment not found for filename: ${filename}`);
+  if (matches.length > 1) {
+    throw new Error(`Multiple attachments named ${filename}; use --file-id instead`);
+  }
+  return matches[0];
+}
+
+function outputPathForAttachment(file, options) {
+  const requested = options.out;
+  const safeName = path.basename(file.filename || file.file_id || "attachment");
+  if (!requested) return path.resolve(safeName);
+  const resolved = path.resolve(requested);
+  if (fs.existsSync(resolved) && fs.statSync(resolved).isDirectory()) {
+    return path.join(resolved, safeName);
+  }
+  return resolved;
+}
+
+async function responseToBuffer(response) {
+  if (typeof response.arrayBuffer === "function") {
+    return Buffer.from(await response.arrayBuffer());
+  }
+  return Buffer.from(await response.text());
+}
+
+async function commandDownloadAttachment(options, deps) {
+  requiredOption(options, "entity");
+  requiredOption(options, "id");
+  const listing = await requestJson(deps, "GET", attachmentPath(options));
+  const files = Array.isArray(listing?.files) ? listing.files : [];
+  const file = pickAttachment(files, options);
+  if (!file.download_url) {
+    throw new Error(`Attachment has no download_url: ${file.file_id || file.filename}`);
+  }
+
+  const response = await deps.fetch(file.download_url, { method: "GET" });
+  const body = await responseToBuffer(response);
+  if (!response.ok) {
+    throw new Error(`Download failed (${response.status}): ${body.toString("utf8")}`);
+  }
+
+  const destination = outputPathForAttachment(file, options);
+  fs.mkdirSync(path.dirname(destination), { recursive: true });
+  fs.writeFileSync(destination, body);
+  return JSON.stringify({
+    file_id: file.file_id || null,
+    filename: file.filename || null,
+    path: destination,
+    bytes: body.length,
+  });
+}
+
+module.exports = {
+  commandDownloadAttachment,
+};