clawlabor 1.11.1

package/runtime/http.js

@@ -0,0 +1,215 @@
+const fs = require("fs");
+const crypto = require("crypto");
+const os = require("os");
+const path = require("path");
+
+const DEFAULT_API_BASE = "https://www.clawlabor.com/api";
+
+function apiBase(_env) {
+  return DEFAULT_API_BASE;
+}
+
+function readCredentialsFile(env) {
+  const candidate = credentialsFilePath(env);
+  if (!fs.existsSync(candidate)) {
+    return null;
+  }
+
+  const parsed = JSON.parse(fs.readFileSync(candidate, "utf8"));
+  return parsed && typeof parsed.api_key === "string" ? parsed.api_key : null;
+}
+
+function credentialsFilePath(env) {
+  return env.CLAWLABOR_CREDENTIALS_FILE ||
+    path.join(os.homedir(), ".config", "clawlabor", "credentials.json");
+}
+
+function writeCredentialsFile(env, credentials) {
+  const candidate = credentialsFilePath(env);
+  fs.mkdirSync(path.dirname(candidate), { recursive: true });
+  fs.writeFileSync(candidate, `${JSON.stringify(credentials, null, 2)}\n`, { mode: 0o600 });
+  try {
+    fs.chmodSync(candidate, 0o600);
+  } catch (_err) {
+    // Best effort. Some filesystems ignore chmod.
+  }
+  return candidate;
+}
+
+function resolveApiKey(env) {
+  return env.CLAWLABOR_API_KEY || readCredentialsFile(env);
+}
+
+function credentialState(env) {
+  const credentialsPath = credentialsFilePath(env);
+  const fileExists = fs.existsSync(credentialsPath);
+  if (env.CLAWLABOR_API_KEY) {
+    return {
+      apiKey: env.CLAWLABOR_API_KEY,
+      source: "CLAWLABOR_API_KEY",
+      credentialsPath,
+      credentialsFileExists: fileExists,
+      credentialsFileError: null,
+    };
+  }
+  let fileKey = null;
+  let fileError = null;
+  try {
+    fileKey = readCredentialsFile(env);
+  } catch (err) {
+    fileError = err;
+  }
+  return {
+    apiKey: fileKey,
+    source: fileKey ? "credentials_file" : null,
+    credentialsPath,
+    credentialsFileExists: fileExists,
+    credentialsFileError: fileError ? fileError.message : null,
+  };
+}
+
+function authHeaders(env) {
+  const apiKey = resolveApiKey(env);
+  if (!apiKey) {
+    const error = new Error(
+      "Set CLAWLABOR_API_KEY or store api_key in ~/.config/clawlabor/credentials.json before calling clawlabor",
+    );
+    error.errorCode = "missing_credentials";
+    throw error;
+  }
+  return {
+    Authorization: `Bearer ${apiKey}`,
+    "Content-Type": "application/json",
+  };
+}
+
+function authOnlyHeaders(env) {
+  const apiKey = resolveApiKey(env);
+  if (!apiKey) {
+    const error = new Error(
+      "Set CLAWLABOR_API_KEY or store api_key in ~/.config/clawlabor/credentials.json before calling clawlabor",
+    );
+    error.errorCode = "missing_credentials";
+    throw error;
+  }
+  return { Authorization: `Bearer ${apiKey}` };
+}
+
+function makeIdempotencyKey() {
+  return `clawlabor-buy-${Date.now()}-${crypto.randomUUID()}`;
+}
+
+function makePublishIdempotencyKey() {
+  return `clawlabor-publish-${Date.now()}-${crypto.randomUUID()}`;
+}
+
+class ApiError extends Error {
+  constructor(status, body) {
+    let parsed = null;
+    try {
+      parsed = JSON.parse(body);
+    } catch (_err) {
+      parsed = null;
+    }
+    const detail = parsed && (parsed.detail || parsed.message || parsed.error);
+    super(`ClawLabor API error ${status}: ${formatApiErrorDetail(detail, body)}`);
+    this.name = "ApiError";
+    this.status = status;
+    this.body = body;
+    this.parsed = parsed;
+    this.errorCode = classifyApiError(status, parsed, body);
+  }
+}
+
+function formatApiErrorDetail(detail, body) {
+  if (detail === undefined || detail === null) return body;
+  if (typeof detail === "string") return detail;
+  try {
+    return JSON.stringify(detail);
+  } catch (_err) {
+    return String(detail);
+  }
+}
+
+function classifyApiError(status, parsed, body) {
+  const text = (
+    (parsed && (parsed.detail || parsed.message || parsed.error)) ||
+    body ||
+    ""
+  ).toString().toLowerCase();
+  if (status === 402 || text.includes("insufficient_credits") || text.includes("insufficient credits")) {
+    return "insufficient_credits";
+  }
+  if (status === 404) return "not_found";
+  if (status === 403) return "forbidden";
+  if (status === 401) return "unauthenticated";
+  if (status === 429) return "rate_limited";
+  return "api_error";
+}
+
+async function request(deps, method, route, { body, headers } = {}) {
+  const url = `${apiBase(deps.env)}${route}`;
+  const response = await deps.fetch(url, {
+    method,
+    headers: { ...authHeaders(deps.env), ...(headers || {}) },
+    body: body !== undefined ? JSON.stringify(body) : undefined,
+  });
+  const text = await response.text();
+  if (!response.ok) {
+    throw new ApiError(response.status, text);
+  }
+  return text;
+}
+
+async function requestNoAuth(deps, method, route, { body, headers } = {}) {
+  const url = `${apiBase(deps.env)}${route}`;
+  const response = await deps.fetch(url, {
+    method,
+    headers: { "Content-Type": "application/json", ...(headers || {}) },
+    body: body !== undefined ? JSON.stringify(body) : undefined,
+  });
+  const text = await response.text();
+  if (!response.ok) {
+    throw new ApiError(response.status, text);
+  }
+  return text;
+}
+
+async function requestJson(deps, method, route, options) {
+  const text = await request(deps, method, route, options);
+  return text ? JSON.parse(text) : {};
+}
+
+async function requestJsonNoAuth(deps, method, route, options) {
+  const text = await requestNoAuth(deps, method, route, options);
+  return text ? JSON.parse(text) : {};
+}
+
+async function requestMultipart(deps, method, route, formData) {
+  const url = `${apiBase(deps.env)}${route}`;
+  const response = await deps.fetch(url, {
+    method,
+    headers: authOnlyHeaders(deps.env),
+    body: formData,
+  });
+  const text = await response.text();
+  if (!response.ok) {
+    throw new ApiError(response.status, text);
+  }
+  return text;
+}
+
+module.exports = {
+  ApiError,
+  apiBase,
+  credentialState,
+  credentialsFilePath,
+  makeIdempotencyKey,
+  makePublishIdempotencyKey,
+  request,
+  requestJson,
+  requestJsonNoAuth,
+  requestMultipart,
+  resolveApiKey,
+  writeCredentialsFile,
+};

package/runtime/options.js

@@ -0,0 +1,36 @@
+function numberOption(options, name) {
+  if (options[name] === undefined) return undefined;
+  const value = Number(options[name]);
+  if (!Number.isFinite(value)) {
+    throw new Error(`--${name} must be a number`);
+  }
+  return value;
+}
+
+function positiveNumberOption(options, name) {
+  const value = numberOption(options, name);
+  if (value !== undefined && value < 1) {
+    throw new Error(`--${name} must be greater than or equal to 1`);
+  }
+  return value;
+}
+
+function requiredOption(options, name) {
+  const value = options[name];
+  if (!value) {
+    throw new Error(`Missing required --${name}`);
+  }
+  return value;
+}
+
+function normalizeWebhookPath(input) {
+  if (!input) return "/webhooks/clawlabor";
+  return input.startsWith("/") ? input : `/${input}`;
+}
+
+module.exports = {
+  normalizeWebhookPath,
+  numberOption,
+  positiveNumberOption,
+  requiredOption,
+};

package/runtime/session.js

@@ -0,0 +1,369 @@
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+function writeInboxEvent(inboxFile, envelope) {
+  fs.mkdirSync(path.dirname(inboxFile), { recursive: true });
+  fs.appendFileSync(inboxFile, `${JSON.stringify(envelope)}\n`);
+}
+
+function defaultOnlineInboxPath(env) {
+  return (
+    env.CLAWLABOR_INBOX_FILE ||
+    path.join(os.homedir(), ".config", "clawlabor", "inbox.jsonl")
+  );
+}
+
+function inboxHasEvent(inboxFile, eventId) {
+  if (!fs.existsSync(inboxFile)) return false;
+  const lines = fs.readFileSync(inboxFile, "utf8").split("\n").filter(Boolean);
+  return lines.some((line) => {
+    try {
+      const item = JSON.parse(line);
+      return Number(item.event_id || 0) === Number(eventId || 0);
+    } catch (_err) {
+      return false;
+    }
+  });
+}
+
+function defaultSessionRoot(env) {
+  return (
+    env.CLAWLABOR_SESSION_ROOT ||
+    path.join(os.homedir(), ".config", "clawlabor", "sessions")
+  );
+}
+
+function defaultSessionId(env) {
+  return (
+    env.CLAWLABOR_SESSION_ID ||
+    env.HERMES_SESSION_ID ||
+    "current"
+  );
+}
+
+function sanitizeSessionId(sessionId) {
+  return String(sessionId || "current").replace(/[^a-zA-Z0-9_.-]+/g, "_");
+}
+
+function sessionDir(sessionRoot, sessionId) {
+  return path.join(sessionRoot, sanitizeSessionId(sessionId));
+}
+
+function sessionStatePath(sessionRoot) {
+  return path.join(sessionRoot, "state.json");
+}
+
+function sessionInboxPath(sessionRoot, sessionId) {
+  return path.join(sessionDir(sessionRoot, sessionId), "inbox.jsonl");
+}
+
+function sessionPromptPath(sessionRoot, sessionId) {
+  return path.join(sessionDir(sessionRoot, sessionId), "prompt.md");
+}
+
+function sessionManifestPath(sessionRoot, sessionId) {
+  return path.join(sessionDir(sessionRoot, sessionId), "manifest.json");
+}
+
+function sessionCursorPath(sessionRoot, sessionId) {
+  return path.join(sessionDir(sessionRoot, sessionId), "cursor.json");
+}
+
+function readJsonFile(filePath, fallback) {
+  try {
+    if (!fs.existsSync(filePath)) return fallback;
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch (_err) {
+    return fallback;
+  }
+}
+
+function writeJsonFile(filePath, value) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+function readSessionState(sessionRoot) {
+  return readJsonFile(sessionStatePath(sessionRoot), {
+    current_session_id: null,
+    sessions: {},
+  });
+}
+
+function writeSessionState(sessionRoot, state) {
+  fs.mkdirSync(sessionRoot, { recursive: true });
+  writeJsonFile(sessionStatePath(sessionRoot), state);
+}
+
+function sessionCursorFor(sessionRoot, sessionId) {
+  return readJsonFile(sessionCursorPath(sessionRoot, sessionId), { last_acked_event_id: 0 });
+}
+
+function writeSessionCursor(sessionRoot, sessionId, lastAckedEventId) {
+  writeJsonFile(sessionCursorPath(sessionRoot, sessionId), {
+    last_acked_event_id: lastAckedEventId,
+    updated_at: new Date().toISOString(),
+  });
+}
+
+function eventContextPayload(event) {
+  return event?.payload && typeof event.payload === "object" ? event.payload : {};
+}
+
+function summarizeSessionPurpose(session) {
+  if (!session) return "No session";
+  if (session.kind === "order" && session.role === "seller") {
+    return `Fulfill order ${session.context_id}`;
+  }
+  if (session.kind === "order" && session.role === "buyer") {
+    return `Review delivery for order ${session.context_id}`;
+  }
+  if (session.kind === "task" && session.role === "requester") {
+    return `Review task ${session.context_id}`;
+  }
+  if (session.kind === "task" && session.role === "provider") {
+    return `Complete task ${session.context_id}`;
+  }
+  return "Process incoming ClawLabor events";
+}
+
+function sessionInstructions(session, latestEvent) {
+  const summary = summarizeSessionPurpose(session);
+  const eventBlock = latestEvent
+    ? JSON.stringify(latestEvent, null, 2)
+    : "{}";
+  if (session.kind === "order" && session.role === "seller") {
+    return [
+      `You are the isolated seller session for order ${session.context_id}.`,
+      "Handle only this order in this session.",
+      "Follow the ClawLabor skill instructions, the SKU/listing description, and the buyer's order requirement.",
+      "Use order details, messages, and attachments as the source of truth.",
+      "Accept the order only when the requirement is clear enough to fulfill.",
+      "Complete the order with the deliverable the buyer requested.",
+      "",
+      `Session purpose: ${summary}`,
+    ].join("\n");
+  }
+  if (session.kind === "order" && session.role === "buyer") {
+    return [
+      `You are the buyer review session for order ${session.context_id}.`,
+      "Use this session to inspect the seller delivery and settle the order.",
+      "Steps:",
+      "1. Fetch the order, messages, and attachments.",
+      "2. Review the delivery note and artifacts.",
+      "3. Confirm if satisfied, or dispute if not.",
+      "",
+      "Latest event:",
+      eventBlock,
+      "",
+      `Session purpose: ${summary}`,
+    ].join("\n");
+  }
+  if (session.kind === "task" && session.role === "requester") {
+    return [
+      `You are the requester session for task ${session.context_id}.`,
+      "Steps:",
+      "1. Fetch the task and messages.",
+      "2. For claim mode, wait until status=submitted then accept or dispute.",
+      "3. For bounty mode, review submissions and select a winner after the deadline.",
+      "",
+      "Latest event:",
+      eventBlock,
+      "",
+      `Session purpose: ${summary}`,
+    ].join("\n");
+  }
+  if (session.kind === "task" && session.role === "provider") {
+    return [
+      `You are the provider session for task ${session.context_id}.`,
+      "Use this session only for this task.",
+      "Steps:",
+      "1. Review the task requirements.",
+      "2. Submit the result or continue working until the result is ready.",
+      "3. Keep task-specific messages isolated here.",
+      "",
+      "Latest event:",
+      eventBlock,
+      "",
+      `Session purpose: ${summary}`,
+    ].join("\n");
+  }
+  return [
+    "You are the current ClawLabor runtime session.",
+    "Use this session to process queued ClawLabor events.",
+    "Review the latest event and take the next required action.",
+    "",
+    "Latest event:",
+    eventBlock,
+    "",
+    `Session purpose: ${summary}`,
+  ].join("\n");
+}
+
+function ensureSession(sessionRoot, state, sessionId, meta = {}, latestEvent = null) {
+  const existing = state.sessions[sessionId] || {};
+  const session = {
+    session_id: sessionId,
+    kind: meta.kind || existing.kind || "current",
+    role: meta.role || existing.role || "current",
+    context_id: meta.context_id ?? existing.context_id ?? null,
+    status: meta.status || existing.status || "active",
+    purpose: meta.purpose || existing.purpose || summarizeSessionPurpose({
+      kind: meta.kind || existing.kind || "current",
+      role: meta.role || existing.role || "current",
+      context_id: meta.context_id ?? existing.context_id ?? null,
+    }),
+    created_at: existing.created_at || new Date().toISOString(),
+    updated_at: new Date().toISOString(),
+    last_event_id: existing.last_event_id || 0,
+  };
+
+  state.sessions[sessionId] = session;
+  fs.mkdirSync(sessionDir(sessionRoot, sessionId), { recursive: true });
+  writeJsonFile(sessionManifestPath(sessionRoot, sessionId), session);
+  fs.writeFileSync(
+    sessionPromptPath(sessionRoot, sessionId),
+    `${sessionInstructions(session, latestEvent)}\n`,
+  );
+  if (!fs.existsSync(sessionInboxPath(sessionRoot, sessionId))) {
+    fs.writeFileSync(sessionInboxPath(sessionRoot, sessionId), "");
+  }
+  if (!fs.existsSync(sessionCursorPath(sessionRoot, sessionId))) {
+    writeSessionCursor(sessionRoot, sessionId, session.last_event_id || 0);
+  }
+  return session;
+}
+
+function sessionEventTarget(event, currentSessionId, state) {
+  const payload = eventContextPayload(event);
+  const eventType = String(event.event_type || "");
+  if (eventType === "order.received") {
+    const orderId = payload.order_id;
+    return orderId
+      ? {
+          sessionId: `order:${orderId}:seller`,
+          meta: {
+            kind: "order",
+            role: "seller",
+            context_id: orderId,
+            purpose: `Fulfill order ${orderId}`,
+          },
+        }
+      : null;
+  }
+  if (eventType === "order.completed") {
+    const orderId = payload.order_id;
+    return {
+      sessionId: currentSessionId,
+      meta: {
+        kind: "order",
+        role: "buyer",
+        context_id: orderId || null,
+        purpose: orderId ? `Review delivery for order ${orderId}` : "Review order delivery",
+      },
+    };
+  }
+  if (eventType === "task.claimed" || eventType === "task.submission_created") {
+    const taskId = payload.task_id;
+    return {
+      sessionId: currentSessionId,
+      meta: {
+        kind: "task",
+        role: "requester",
+        context_id: taskId || null,
+        purpose: taskId ? `Review task ${taskId}` : "Review task activity",
+      },
+    };
+  }
+  if (eventType === "message.received" || eventType === "dispute.raised" || eventType === "dispute.resolved") {
+    const orderId =
+      payload.order_id ||
+      (payload.context_type === "order" ? payload.context_id : null);
+    const taskId =
+      payload.task_id ||
+      (payload.context_type === "task" ? payload.context_id : null);
+    const candidate = orderId
+      ? `order:${orderId}:seller`
+      : taskId
+        ? `task:${taskId}:requester`
+        : null;
+    const hasContextSession = candidate && state.sessions[candidate];
+    const sessionId = hasContextSession ? candidate : currentSessionId;
+    return {
+      sessionId,
+      meta: {
+        kind: hasContextSession ? (orderId ? "order" : "task") : "current",
+        role: hasContextSession ? (orderId ? "seller" : "requester") : "current",
+        context_id: hasContextSession ? (orderId || taskId || null) : null,
+        purpose: hasContextSession
+          ? orderId
+            ? `Handle messages for order ${orderId}`
+            : `Handle messages for task ${taskId}`
+          : "Handle incoming platform event in the current agent session",
+      },
+    };
+  }
+  return {
+    sessionId: currentSessionId,
+    meta: {
+      kind: "current",
+      role: "current",
+      context_id: null,
+      purpose: "Process incoming ClawLabor events",
+    },
+  };
+}
+
+function appendSessionEvent(sessionRoot, sessionId, envelope) {
+  const inbox = sessionInboxPath(sessionRoot, sessionId);
+  fs.mkdirSync(path.dirname(inbox), { recursive: true });
+  if (inboxHasEvent(inbox, envelope.event_id)) return;
+  fs.appendFileSync(inbox, `${JSON.stringify(envelope)}\n`);
+}
+
+function sessionEvents(sessionRoot, sessionId) {
+  const inbox = sessionInboxPath(sessionRoot, sessionId);
+  if (!fs.existsSync(inbox)) return [];
+  return fs
+    .readFileSync(inbox, "utf8")
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch (_err) {
+        return null;
+      }
+    })
+    .filter(Boolean);
+}
+
+module.exports = {
+  appendSessionEvent,
+  defaultOnlineInboxPath,
+  defaultSessionId,
+  defaultSessionRoot,
+  ensureSession,
+  eventContextPayload,
+  inboxHasEvent,
+  readJsonFile,
+  readSessionState,
+  sanitizeSessionId,
+  sessionCursorFor,
+  sessionCursorPath,
+  sessionDir,
+  sessionEventTarget,
+  sessionEvents,
+  sessionInboxPath,
+  sessionInstructions,
+  sessionManifestPath,
+  sessionPromptPath,
+  sessionStatePath,
+  summarizeSessionPurpose,
+  writeInboxEvent,
+  writeJsonFile,
+  writeSessionCursor,
+  writeSessionState,
+};