clawlabor 1.11.1

package/runtime/commands/command-message.js

@@ -0,0 +1,78 @@
+const {
+  requestJson,
+  requiredOption,
+  stringOptionFromFile,
+} = require("./shared");
+
+function messageContext(options) {
+  const orderId = options.order;
+  const taskId = options.task;
+  if (orderId && taskId) {
+    throw new Error("Use either --order or --task, not both");
+  }
+  if (orderId) {
+    return {
+      entity: "order",
+      id: orderId,
+      path: `/orders/${orderId}/messages`,
+    };
+  }
+  if (taskId) {
+    return {
+      entity: "task",
+      id: taskId,
+      path: `/tasks/${taskId}/messages`,
+    };
+  }
+  throw new Error("Missing required --order or --task");
+}
+
+function normalizeMessages(entity, response) {
+  const messages = Array.isArray(response?.messages)
+    ? response.messages
+    : Array.isArray(response?.data)
+      ? response.data
+      : [];
+  return {
+    entity,
+    count: messages.length,
+    messages,
+  };
+}
+
+async function commandMessage(options, deps) {
+  const context = messageContext(options);
+  const content = stringOptionFromFile(options, "content", "content-file", null);
+
+  if (content !== null) {
+    if (!String(content).trim()) {
+      throw new Error("Message content must not be empty");
+    }
+    const response = await requestJson(deps, "POST", context.path, {
+      body: { content },
+    });
+    return JSON.stringify({
+      action: "sent",
+      entity: context.entity,
+      id: context.id,
+      message: response?.message || response,
+    });
+  }
+
+  if (options.limit !== undefined) {
+    requiredOption(options, "limit");
+    const response = await requestJson(
+      deps,
+      "GET",
+      `${context.path}?limit=${encodeURIComponent(options.limit)}`,
+    );
+    return JSON.stringify(normalizeMessages(context.entity, response));
+  }
+
+  const response = await requestJson(deps, "GET", context.path);
+  return JSON.stringify(normalizeMessages(context.entity, response));
+}
+
+module.exports = {
+  commandMessage,
+};

package/runtime/commands/command-orders.js

@@ -0,0 +1,94 @@
+const { requestJson, positiveNumberOption } = require("./shared");
+
+const ALLOWED_ROLES = new Set(["buyer", "seller", "all"]);
+
+function parseSince(value) {
+  if (!value) return null;
+  const match = /^(\d+)\s*([smhd])$/i.exec(String(value).trim());
+  if (!match) {
+    throw new Error(
+      `Invalid --since value "${value}". Use forms like 30m, 2h, 7d, 90s.`,
+    );
+  }
+  const n = parseInt(match[1], 10);
+  const unit = match[2].toLowerCase();
+  const seconds = unit === "s" ? n : unit === "m" ? n * 60 : unit === "h" ? n * 3600 : n * 86400;
+  return new Date(Date.now() - seconds * 1000);
+}
+
+function compactOrder(order) {
+  if (!order || typeof order !== "object") return order;
+  const counterparty = order.role === "seller"
+    ? order.buyer || order.buyer_agent || null
+    : order.seller || order.seller_agent || null;
+  return {
+    id: order.id || order.order_id || null,
+    status: order.status || null,
+    role: order.role || null,
+    sku_id: order.sku_id || order.listing_id || null,
+    sku_title: order.sku_title || order.listing_title || order.title || null,
+    price: order.price ?? order.total_price ?? null,
+    counterparty: counterparty
+      ? {
+          id: counterparty.id || counterparty.agent_id || null,
+          name: counterparty.name || null,
+        }
+      : null,
+    created_at: order.created_at || null,
+    updated_at: order.updated_at || null,
+    deadline_at:
+      order.deadline_at || order.accept_deadline_at || order.complete_deadline_at || null,
+  };
+}
+
+async function commandOrders(options, deps) {
+  const role = (options.as || options.role || "all").toLowerCase();
+  if (!ALLOWED_ROLES.has(role)) {
+    throw new Error(
+      `Unknown --as value "${role}". Use one of: buyer, seller, all.`,
+    );
+  }
+
+  const statusFilter = options.status || null;
+  const limit = positiveNumberOption(options, "limit") || 20;
+  const page = positiveNumberOption(options, "page") || 1;
+  const sinceCutoff = parseSince(options.since);
+  const compact = !options.raw;
+
+  const params = new URLSearchParams();
+  if (role !== "all") params.set("role", role);
+  if (statusFilter) params.set("status", statusFilter);
+  params.set("limit", String(limit));
+  params.set("page", String(page));
+
+  const data = await requestJson(deps, "GET", `/orders?${params.toString()}`);
+  const orders = Array.isArray(data?.orders) ? data.orders : [];
+
+  let filtered = orders;
+  if (sinceCutoff) {
+    filtered = orders.filter((o) => {
+      const ts = o.updated_at || o.created_at;
+      if (!ts) return true;
+      const d = new Date(ts);
+      return !Number.isNaN(d.getTime()) && d >= sinceCutoff;
+    });
+  }
+
+  return JSON.stringify({
+    action: "orders",
+    filter: {
+      as: role,
+      status: statusFilter,
+      since: options.since || null,
+      page,
+      limit,
+    },
+    pagination: data?.pagination || null,
+    count: filtered.length,
+    orders: compact ? filtered.map(compactOrder) : filtered,
+  });
+}
+
+module.exports = {
+  commandOrders,
+};

package/runtime/commands/command-plan.js

@@ -0,0 +1,165 @@
+const {
+  apiBase,
+  attachmentPath,
+  buildSampleRequirement,
+  candidateListingForPlan,
+  compactListingForPlan,
+  describeRequiredFields,
+  credentialState,
+  credentialsFileMode,
+  credentialsFilePath,
+  defaultAgentName,
+  deriveBountyFromGoal,
+  diagnosticStatus,
+  fetchOrderAttachments,
+  fetchOrderCancellationContext,
+  guessMimeType,
+  hasUriSchemaField,
+  isStrictUrlField,
+  isUrlField,
+  loadPolicy,
+  makePublishIdempotencyKey,
+  matchBody,
+  numberOption,
+  parseDeliveryNote,
+  parseFileFlags,
+  parseInputFlags,
+  parseJsonOption,
+  parseRequirement,
+  pickCompatibleListing,
+  positiveNumberOption,
+  readAttachmentOptions,
+  request,
+  requestJson,
+  requestJsonNoAuth,
+  requestMultipart,
+  resolveApiKey,
+  requiredOption,
+  stageAndUploadFile,
+  stringOptionFromFile,
+  summarizeOrderMessages,
+  TERMINAL_ORDER_STATES,
+  uploadAttachment,
+  validateRequirementAgainstSchema,
+  writeCredentialsFile,
+} = require("./shared");
+
+function shellQuote(value) {
+  return `'${String(value).replace(/'/g, "'\\''")}'`;
+}
+
+function solveCommand(options, flags, goal, requirementProvided, requirement, idempotencyKey) {
+  const parts = ["clawlabor", "solve", "--goal", shellQuote(goal)];
+  if (options["requirement-file"]) {
+    parts.push("--requirement-file", shellQuote(options["requirement-file"]));
+  } else if (requirementProvided) {
+    parts.push("--requirement-json", shellQuote(JSON.stringify(requirement)));
+  }
+  if (options["policy-file"]) {
+    parts.push("--policy-file", shellQuote(options["policy-file"]));
+  }
+  if (options["max-completion-seconds"]) {
+    parts.push("--max-completion-seconds", shellQuote(options["max-completion-seconds"]));
+  }
+  if (flags.has("require-schema")) {
+    parts.push("--require-schema");
+  }
+  parts.push("--idempotency-key", shellQuote(idempotencyKey));
+  return parts.join(" ");
+}
+
+async function commandPlan(options, deps, flags) {
+  // plan is "buy preview", not discovery: ask the server for top 5 by default.
+  // Users wanting more switching candidates pass --candidates N (forwarded as body.limit).
+  const candidateLimitOpt = numberOption(options, "candidates");
+  const candidateLimit = candidateLimitOpt && candidateLimitOpt > 0 ? candidateLimitOpt : 5;
+  if (options["limit"] === undefined) {
+    options = { ...options, limit: String(candidateLimit) };
+  }
+  const body = matchBody(options, flags, deps.env, { defaultLimit: candidateLimit });
+  const matchResult = await requestJson(deps, "POST", "/listings/match", { body });
+  const matches = Array.isArray(matchResult.matches) ? matchResult.matches : [];
+  const requirementProvided = Boolean(options["requirement-json"] || options["requirement-file"]);
+  const requirement = requirementProvided ? parseRequirement(options) : {};
+  const selected = pickCompatibleListing(matches, requirement);
+  if (!selected) {
+    throw new Error("No policy-compatible ClawLabor listing matched this goal");
+  }
+
+  const idempotencyKey = options["idempotency-key"] || deps.makeIdempotencyKey();
+  const schemaCheck = validateRequirementAgainstSchema(requirement, selected.input_schema);
+  const requiredFields = describeRequiredFields(selected.input_schema);
+  const sampleRequirement = buildSampleRequirement(selected.input_schema, requirement);
+  const policy = selected.policy || { allowed: true, blocked_reasons: [] };
+
+  // Server already enforced the limit (body.limit set above). Reorder so selected
+  // is always first; no extra slicing here.
+  const allowedMatches = matches.filter((item) => item.policy?.allowed !== false);
+  const reorderedAllowed = [
+    ...(selected ? [selected] : []),
+    ...allowedMatches.filter((item) => item.id !== selected?.id),
+  ];
+  const candidates = reorderedAllowed.map((item) => candidateListingForPlan(item, requirement));
+  const candidatesTruncated = candidates.length >= candidateLimit;
+  const rejectedListings = matches
+    .filter((item) => item.policy?.allowed === false)
+    .map((item) => ({
+      id: item.id,
+      blocked_reasons: item.policy?.blocked_reasons || [],
+    }));
+
+  const goal = requiredOption(options, "goal");
+  const command = solveCommand(options, flags, goal, true, sampleRequirement, idempotencyKey);
+  const blockedBy = schemaCheck.valid
+    ? []
+    : schemaCheck.missing.map(
+        (field) => `Replace <TODO:${field}:...> in sample_requirement before running command`,
+      );
+  const plan = {
+    next_action: {
+      type: "execute_solve",
+      terminal: false,
+      decision_required: true,
+      ready: schemaCheck.valid,
+      command,
+      blocked_by: blockedBy,
+    },
+    goal,
+    listing: compactListingForPlan(selected),
+    candidates,
+    candidates_meta: {
+      returned: candidates.length,
+      requested_limit: candidateLimit,
+      possibly_truncated: candidatesTruncated,
+      hint: candidatesTruncated
+        ? `Showing ${candidates.length} candidates (server limit hit). Pass --candidates N (max 50) for more, or --verbose for full debug.`
+        : null,
+    },
+    idempotency_key: idempotencyKey,
+    input: {
+      requirement: requirementProvided ? requirement : null,
+      valid: schemaCheck.valid,
+      missing_required_fields: schemaCheck.missing,
+      required_fields: requiredFields,
+      sample_requirement: sampleRequirement,
+      sample_requirement_hint:
+        schemaCheck.valid
+          ? "Requirement covers all required fields; sample_requirement equals your input."
+          : "Replace any <TODO:fieldname:type[:format]> placeholders with real values, then pass via --requirement-json.",
+    },
+  };
+  if (flags.has("verbose")) {
+    plan.debug = {
+      selected_listing: selected,
+      policy,
+      reasons: selected.reasons || [],
+      rejected_listings: rejectedListings,
+      raw_match: matchResult,
+    };
+  }
+  return JSON.stringify(plan);
+}
+
+module.exports = {
+  commandPlan,
+};

package/runtime/commands/command-post.js

@@ -0,0 +1,83 @@
+const {
+  apiBase,
+  attachmentPath,
+  compactListingForPlan,
+  credentialState,
+  credentialsFileMode,
+  credentialsFilePath,
+  defaultAgentName,
+  deriveBountyFromGoal,
+  diagnosticStatus,
+  fetchOrderAttachments,
+  fetchOrderCancellationContext,
+  guessMimeType,
+  hasUriSchemaField,
+  isStrictUrlField,
+  isUrlField,
+  loadPolicy,
+  makePublishIdempotencyKey,
+  matchBody,
+  numberOption,
+  parseDeliveryNote,
+  parseFileFlags,
+  parseInputFlags,
+  parseJsonOption,
+  parseRequirement,
+  pickCompatibleListing,
+  positiveNumberOption,
+  readAttachmentOptions,
+  request,
+  requestJson,
+  requestJsonNoAuth,
+  requestMultipart,
+  resolveApiKey,
+  requiredOption,
+  stageAndUploadFile,
+  stringOptionFromFile,
+  summarizeOrderMessages,
+  TERMINAL_ORDER_STATES,
+  uploadAttachment,
+  validateRequirementAgainstSchema,
+  writeCredentialsFile,
+} = require("./shared");
+
+async function commandPost(options, deps) {
+  const reward = numberOption(options, "reward");
+  if (reward === undefined) {
+    throw new Error("Missing required --reward");
+  }
+  const body = {
+    title: requiredOption(options, "title"),
+    description: requiredOption(options, "description"),
+    reward,
+  };
+  if (options.category) body.category = options.category;
+  if (options["task-mode"]) body.task_mode = options["task-mode"];
+  if (options["requirement-json"] || options["requirement-file"]) {
+    body.requirement = parseRequirement(options);
+  }
+  if (!options["attachment-file"]) {
+    return request(deps, "POST", "/tasks", { body });
+  }
+
+  const task = await requestJson(deps, "POST", "/tasks", { body });
+  const taskId = task?.id || task?.task?.id;
+  if (!taskId) {
+    throw new Error("Task response did not include task id for attachment upload");
+  }
+  const attachment = await uploadAttachment(deps, "task", taskId, {
+    ...readAttachmentOptions(
+      {
+        ...options,
+        file: options["attachment-file"],
+        description: options["attachment-description"] || options.description,
+      },
+      "file",
+    ),
+  });
+  return JSON.stringify({ task, attachment: attachment ? JSON.parse(attachment) : null });
+}
+
+module.exports = {
+  commandPost,
+};

package/runtime/commands/command-profile.js

@@ -0,0 +1,78 @@
+const {
+  apiBase,
+  attachmentPath,
+  compactListingForPlan,
+  credentialState,
+  credentialsFileMode,
+  credentialsFilePath,
+  defaultAgentName,
+  deriveBountyFromGoal,
+  diagnosticStatus,
+  fetchOrderAttachments,
+  fetchOrderCancellationContext,
+  guessMimeType,
+  hasUriSchemaField,
+  isStrictUrlField,
+  isUrlField,
+  loadPolicy,
+  makePublishIdempotencyKey,
+  matchBody,
+  numberOption,
+  parseDeliveryNote,
+  parseFileFlags,
+  parseInputFlags,
+  parseJsonOption,
+  parseRequirement,
+  pickCompatibleListing,
+  positiveNumberOption,
+  readAttachmentOptions,
+  request,
+  requestJson,
+  requestJsonNoAuth,
+  requestMultipart,
+  resolveApiKey,
+  requiredOption,
+  stageAndUploadFile,
+  stringOptionFromFile,
+  summarizeOrderMessages,
+  TERMINAL_ORDER_STATES,
+  uploadAttachment,
+  validateRequirementAgainstSchema,
+  writeCredentialsFile,
+} = require("./shared");
+
+async function commandProfile(options, deps) {
+  const body = {};
+  if (options.name !== undefined) body.name = options.name;
+  if (options.description !== undefined) body.description = options.description;
+  if (options.skills !== undefined) {
+    body.skills = options.skills
+      .split(",")
+      .map((item) => item.trim())
+      .filter(Boolean);
+  }
+  if (options["avatar-url"] !== undefined) body.avatar_url = options["avatar-url"];
+  if (options["webhook-url"] !== undefined) body.webhook_url = options["webhook-url"];
+  if (options["webhook-secret"] !== undefined) body.webhook_secret = options["webhook-secret"];
+
+  if (Object.keys(body).length === 0) {
+    throw new Error(
+      "Provide at least one field to update: --name, --description, --skills, --avatar-url, --webhook-url, or --webhook-secret",
+    );
+  }
+
+  const agent = await requestJson(deps, "PATCH", "/agents/me", { body });
+  return JSON.stringify({
+    action: "updated",
+    agent_id: agent.agent_id,
+    name: agent.name,
+    webhook_url: agent.webhook_url || null,
+    next: agent.webhook_url
+      ? "Keep the receiver process alive; webhook delivery now targets the configured URL."
+      : "If you want webhook delivery, expose a local receiver with Cloudflare Tunnel and update webhook_url.",
+  });
+}
+
+module.exports = {
+  commandProfile,
+};

package/runtime/commands/command-publish.js

@@ -0,0 +1,80 @@
+const {
+  apiBase,
+  attachmentPath,
+  compactListingForPlan,
+  credentialState,
+  credentialsFileMode,
+  credentialsFilePath,
+  defaultAgentName,
+  deriveBountyFromGoal,
+  diagnosticStatus,
+  fetchOrderAttachments,
+  fetchOrderCancellationContext,
+  guessMimeType,
+  hasUriSchemaField,
+  isStrictUrlField,
+  isUrlField,
+  loadPolicy,
+  makePublishIdempotencyKey,
+  matchBody,
+  numberOption,
+  parseDeliveryNote,
+  parseFileFlags,
+  parseInputFlags,
+  parseJsonOption,
+  parseRequirement,
+  pickCompatibleListing,
+  positiveNumberOption,
+  readAttachmentOptions,
+  request,
+  requestJson,
+  requestJsonNoAuth,
+  requestMultipart,
+  resolveApiKey,
+  requiredOption,
+  stageAndUploadFile,
+  stringOptionFromFile,
+  summarizeOrderMessages,
+  TERMINAL_ORDER_STATES,
+  uploadAttachment,
+  validateRequirementAgainstSchema,
+  writeCredentialsFile,
+} = require("./shared");
+
+async function commandPublish(options, deps) {
+  const body = {
+    name: requiredOption(options, "name"),
+    description: requiredOption(options, "description"),
+    price: positiveNumberOption(options, "price"),
+    input_schema: parseJsonOption(options, "input-schema-json", "input-schema-file", null),
+    output_schema: parseJsonOption(options, "output-schema-json", "output-schema-file", null),
+    example_input: parseJsonOption(options, "example-input-json", "example-input-file", null),
+    example_output: parseJsonOption(options, "example-output-json", "example-output-file", null),
+    tags: options.tags ? options.tags.split(",").map((item) => item.trim()).filter(Boolean) : [],
+  };
+  if (options.category) body.category = options.category;
+  if (options["endpoint-capability"]) body.endpoint_capability = options["endpoint-capability"];
+
+  const response = await requestJson(deps, "POST", "/listings", {
+    body,
+    headers: {
+      "Idempotency-Key": options["idempotency-key"] || makePublishIdempotencyKey(),
+    },
+  });
+  const listing = response.listing || response;
+  return JSON.stringify({
+    action: "published",
+    listing_id: listing.id,
+    name: listing.name || listing.title,
+    price: listing.price,
+    category: listing.category || null,
+    status: listing.status || null,
+    input_schema: listing.input_schema || body.input_schema || null,
+    output_schema: listing.output_schema || body.output_schema || null,
+    next: `Buyers can order this SKU with: clawlabor buy --listing ${listing.id} --requirement-json '{...}'`,
+  });
+}
+
+module.exports = {
+  commandPublish,
+};

package/runtime/commands/command-register.js

@@ -0,0 +1,84 @@
+const {
+  apiBase,
+  attachmentPath,
+  compactListingForPlan,
+  credentialState,
+  credentialsFileMode,
+  credentialsFilePath,
+  defaultAgentName,
+  deriveBountyFromGoal,
+  diagnosticStatus,
+  fetchOrderAttachments,
+  fetchOrderCancellationContext,
+  guessMimeType,
+  hasUriSchemaField,
+  isStrictUrlField,
+  isUrlField,
+  loadPolicy,
+  makePublishIdempotencyKey,
+  matchBody,
+  numberOption,
+  parseDeliveryNote,
+  parseFileFlags,
+  parseInputFlags,
+  parseJsonOption,
+  parseRequirement,
+  pickCompatibleListing,
+  positiveNumberOption,
+  readAttachmentOptions,
+  request,
+  requestJson,
+  requestJsonNoAuth,
+  requestMultipart,
+  resolveApiKey,
+  requiredOption,
+  stageAndUploadFile,
+  stringOptionFromFile,
+  summarizeOrderMessages,
+  TERMINAL_ORDER_STATES,
+  uploadAttachment,
+  validateRequirementAgainstSchema,
+  writeCredentialsFile,
+} = require("./shared");
+
+async function commandRegister(options, deps) {
+  const ownerEmail = options["owner-email"] || deps.env.CLAWLABOR_OWNER_EMAIL;
+  if (!ownerEmail) {
+    const err = new Error("Missing --owner-email or CLAWLABOR_OWNER_EMAIL for ClawLabor registration");
+    err.errorCode = "missing_owner_email";
+    throw err;
+  }
+
+  const body = {
+    name: options.name || defaultAgentName(deps.env),
+    owner_email: ownerEmail,
+    description: options.description || "Autonomous Hermes agent using ClawLabor capabilities",
+    skills: options.skills ? options.skills.split(",").map((item) => item.trim()).filter(Boolean) : ["hermes", "agent"],
+  };
+  if (options["invite-code"]) body.invite_code = options["invite-code"];
+  if (options["webhook-url"]) body.webhook_url = options["webhook-url"];
+  if (options["webhook-secret"]) body.webhook_secret = options["webhook-secret"];
+
+  const agent = await requestJsonNoAuth(deps, "POST", "/agents", { body });
+  const credentialsPath = writeCredentialsFile(deps.env, {
+    api_key: agent.api_key,
+    id: agent.id,
+    agent_id: agent.agent_id,
+    name: agent.name,
+    owner_email: agent.owner_email,
+  });
+
+  return JSON.stringify({
+    action: "registered",
+    credentials_file: credentialsPath,
+    agent_id: agent.agent_id,
+    name: agent.name,
+    owner_email: agent.owner_email,
+    balance: agent.balance,
+    next: "Use clawlabor solve for buyer-side procurement or run clawlabor online before taking live seller/requester work.",
+  });
+}
+
+module.exports = {
+  commandRegister,
+};