@linkedclaw/cli 0.1.2 → 0.1.3

package/package.json

@@ -1,49 +1,34 @@
 {
   "name": "@linkedclaw/cli",
-  "version": "0.1.2",
-  "description": "Official LinkedClaw CLI — any agent can shell out to hire providers, invoke, broadcast, or run as a provider",
-  "license": "Apache-2.0",
+  "version": "0.1.3",
+  "description": "LinkedClaw command-line interface",
   "type": "module",
   "bin": {
     "linkedclaw": "./dist/bin.js"
   },
-  "files": [
-    "dist",
-    "LICENSE",
-    "README.md"
-  ],
-  "keywords": [
-    "linkedclaw",
-    "cli",
-    "agent",
-    "marketplace"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/linkedclaw/linkedclaw.git",
-    "directory": "typescript/packages/cli"
-  },
-  "publishConfig": {
-    "access": "public"
+  "engines": {
+    "node": ">=20"
   },
   "dependencies": {
-    "@linkedclaw/core": "^0.1.2",
     "commander": "^12.1.0",
-    "js-yaml": "^4.1.0"
+    "js-yaml": "^4.1.0",
+    "open": "^10.1.0",
+    "ws": "^8.0.0",
+    "@linkedclaw/provider-runtime": "^0.9.1",
+    "@linkedclaw/consumer-runtime": "^0.9.1",
+    "@linkedclaw/provider": "^0.9.1",
+    "@linkedclaw/consumer": "^0.9.1"
   },
   "devDependencies": {
-    "@types/js-yaml": "^4.0.9"
-  },
-  "engines": {
-    "node": ">=18"
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^20.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.4.0",
+    "vitest": "^1.6.0"
   },
   "scripts": {
     "build": "tsup",
-    "dev": "tsup --watch",
-    "test": "vitest run",
-    "test:watch": "vitest",
     "typecheck": "tsc --noEmit",
-    "clean": "rm -rf dist",
-    "start": "node dist/bin.js"
+    "test": "vitest run"
   }
 }

package/src/bin.ts

@@ -0,0 +1,23 @@
+import { Command } from "commander";
+import { registerAuthCommands } from "./commands/auth.js";
+import { registerProviderCommands } from "./commands/provider.js";
+import { registerRequesterCommands } from "./commands/requester.js";
+
+const CLI_VERSION = "0.1.2";
+
+const program = new Command();
+program
+  .name("linkedclaw")
+  .description("Official LinkedClaw CLI — any agent can shell out to hire providers, invoke, or broadcast")
+  .version(`cli ${CLI_VERSION}`);
+
+registerAuthCommands(program);
+registerRequesterCommands(program);
+registerProviderCommands(program);
+
+program.parseAsync(process.argv).catch((err) => {
+  process.stderr.write(
+    JSON.stringify({ error: "internal_error", message: err instanceof Error ? err.message : String(err) }) + "\n",
+  );
+  process.exit(1);
+});

package/src/commands/auth.ts

@@ -0,0 +1,116 @@
+import { Command } from "commander";
+import { configPath, readFileConfig, writeFileConfig, DEFAULT_CLOUD_URL } from "../config.js";
+import { buildContext } from "../context.js";
+import { runCommand, readLine } from "../output.js";
+
+export function registerAuthCommands(program: Command): void {
+  program
+    .command("login")
+    .description("Store API key in ~/.linkedclaw/config.yaml")
+    .option("--api-key <key>", "API key (otherwise read from stdin)")
+    .option("--cloud-url <url>", "Override cloud URL")
+    .action(async (opts) => {
+      await runCommand(async () => {
+        let apiKey = opts.apiKey as string | undefined;
+        if (!apiKey) {
+          apiKey = await readLine("Paste API key: ");
+        }
+        if (!apiKey) throw new Error("empty api key");
+        const prev = readFileConfig();
+        const next = { ...prev, apiKey, ...(opts.cloudUrl ? { cloudUrl: opts.cloudUrl } : {}) };
+        writeFileConfig(next);
+        return { ok: true, path: configPath() };
+      });
+    });
+
+  program
+    .command("register")
+    .description("Open browser to create a LinkedClaw account, then paste your API key")
+    .option("--no-browser", "Print URL instead of attempting to open the browser")
+    .option("--cloud-url <url>", "Override cloud URL")
+    .action(async (opts) => {
+      await runCommand(async () => {
+        const prev = readFileConfig();
+        const cloudUrl =
+          (opts.cloudUrl as string | undefined) ??
+          (prev.cloudUrl as string | undefined) ??
+          process.env.LINKEDCLAW_CLOUD_URL ??
+          DEFAULT_CLOUD_URL;
+        const portalUrl = cloudUrl.replace(/\/$/, "") + "/register";
+
+        let opened = false;
+        if (opts.browser !== false) {
+          try {
+            const open = (await import("open")).default;
+            await open(portalUrl);
+            opened = true;
+          } catch {
+            // headless / no DISPLAY / package missing → fall through to URL print
+          }
+        }
+        if (!opened) {
+          process.stderr.write(`Open this URL in a browser to register:\n  ${portalUrl}\n\n`);
+        }
+
+        const apiKey = await readLine("Paste your API key (from portal Settings → API Keys): ");
+        if (!apiKey) throw new Error("empty api key");
+
+        const next = {
+          ...prev,
+          apiKey,
+          cloudUrl,
+        };
+        writeFileConfig(next);
+        return { ok: true, path: configPath(), opened };
+      });
+    });
+
+  program
+    .command("whoami")
+    .description("Print current user info")
+    .option("--human", "Human-readable output")
+    .action(async (opts) => {
+      await runCommand(async () => {
+        const { consumer } = buildContext();
+        return consumer.getMe();
+      }, { human: opts.human });
+    });
+
+  const config = program
+    .command("config")
+    .description("Inspect or edit local config file");
+
+  config
+    .command("show")
+    .description("Print the config file contents (api key redacted)")
+    .action(async () => {
+      await runCommand(async () => {
+        const raw = readFileConfig();
+        const redacted = { ...raw };
+        if (redacted.apiKey) redacted.apiKey = "lc_***" + String(redacted.apiKey).slice(-4);
+        return { path: configPath(), config: redacted };
+      });
+    });
+
+  config
+    .command("set <key> <value>")
+    .description("Set a config key (simple top-level keys only)")
+    .action(async (key: string, value: string) => {
+      await runCommand(async () => {
+        const prev = readFileConfig();
+        const next: Record<string, unknown> = { ...prev };
+        const parsed = tryParseJson(value);
+        next[key] = parsed;
+        writeFileConfig(next);
+        return { ok: true, key, value: parsed };
+      });
+    });
+}
+
+function tryParseJson(v: string): unknown {
+  try {
+    return JSON.parse(v);
+  } catch {
+    return v;
+  }
+}

package/src/commands/provider.ts

@@ -0,0 +1,245 @@
+import { Command } from "commander";
+import { readFileSync } from "node:fs";
+import { load as yamlLoad } from "js-yaml";
+import {
+  ProviderRuntime,
+  RelayClient,
+  type ProviderHandler,
+} from "@linkedclaw/provider-runtime";
+import type { CreateAgentRequest, UpdateAgentRequest, BroadcastSubmitRequest } from "../types.js";
+import type { ProviderConfig } from "../config.js";
+import { buildContext } from "../context.js";
+import { SubprocessHandler } from "../handlers/subprocess.js";
+import { readStdin, runCommand, printError } from "../output.js";
+
+export function registerProviderCommands(program: Command): void {
+  const provider = program.command("provider").description("Provider-side commands");
+
+  provider
+    .command("register <config>")
+    .description("Register (create/update) an agent listing from a provider YAML file. Use \"-\" for stdin.")
+    .option("--human", "Human-readable output")
+    .action(async (path: string, opts) => {
+      await runCommand(async () => {
+        const cfg = await loadProviderYaml(path);
+        const { providerClient } = buildContext();
+        const body = buildCreateAgentRequest(cfg);
+        if (cfg.agentId) {
+          return providerClient.updateAgent(cfg.agentId, body as unknown as Record<string, unknown>);
+        }
+        return providerClient.createAgent({
+          slug: body.slug,
+          name: body.name,
+          description: body.description ?? "",
+          capabilities: body.capabilities,
+        });
+      }, { human: opts.human });
+    });
+
+  provider
+    .command("update <listing_id>")
+    .description("Patch an existing agent listing. Body = JSON file or stdin.")
+    .requiredOption("--body <json>", 'JSON body (or "-" to read from stdin)')
+    .option("--human", "Human-readable output")
+    .action(async (listingId: string, opts) => {
+      await runCommand(async () => {
+        const raw = opts.body === "-" ? await readStdin() : readFileSync(opts.body, "utf8");
+        const body = JSON.parse(raw) as UpdateAgentRequest;
+        const { providerClient } = buildContext();
+        return providerClient.updateAgent(listingId, body as unknown as Record<string, unknown>);
+      }, { human: opts.human });
+    });
+
+  provider
+    .command("listings")
+    .description("Show my own agent listings (as provider)")
+    .option("--human", "Human-readable output")
+    .action(async (opts) => {
+      await runCommand(async () => {
+        const { consumer } = buildContext();
+        return consumer.discover({ owner: "me" });
+      }, { human: opts.human });
+    });
+
+  provider
+    .command("run <config>")
+    .description("Run a provider daemon: connect WS, dispatch events to handler subprocess")
+    .option("--handler-cmd <cmd>", "Shell command to spawn as the handler child process")
+    .option("--handler-http <url>", "HTTP webhook URL to POST each event to (alternative to --handler-cmd)")
+    .option("--human", "Human-readable status output")
+    .action(async (path: string, opts) => {
+      try {
+      const yamlCfg = await loadProviderYaml(path);
+      if (!yamlCfg.agentId) {
+        process.stderr.write(
+          JSON.stringify({ error: "provider_unconfigured", message: "agentId missing — run `linkedclaw provider register` first or set it in YAML" }) + "\n",
+        );
+        process.exit(1);
+      }
+      if (!opts.handlerCmd && !opts.handlerHttp) {
+        process.stderr.write(
+          JSON.stringify({ error: "config_error", message: "either --handler-cmd or --handler-http is required" }) + "\n",
+        );
+        process.exit(1);
+      }
+      if (opts.handlerCmd && opts.handlerHttp) {
+        process.stderr.write(
+          JSON.stringify({ error: "config_error", message: "--handler-cmd and --handler-http are mutually exclusive" }) + "\n",
+        );
+        process.exit(1);
+      }
+
+      const { providerClient, cfg: merged } = buildContext({ ...yamlCfg });
+      const relay = new RelayClient({
+        url: merged.relayUrl,
+        apiKey: merged.apiKey!,
+        agentId: merged.agentId!,
+      });
+      const handler = opts.handlerCmd
+        ? new SubprocessHandler({ cmd: opts.handlerCmd as string })
+        : makeHttpHandler(opts.handlerHttp as string);
+
+      const runtime = new ProviderRuntime({
+        cloud: {
+          broadcasts: {
+            accept: (taskId, body) => providerClient.acceptGigTask(taskId, body as unknown as Record<string, unknown>),
+            submit: (taskId, body) => providerClient.submitGigTask(taskId, body as unknown as Record<string, unknown>),
+          },
+        },
+        relay,
+        handler,
+        config: merged,
+      });
+
+      let stopping = false;
+      const shutdown = async (sig: string) => {
+        if (stopping) return;
+        stopping = true;
+        process.stderr.write(`\n[provider] received ${sig}, stopping...\n`);
+        await runtime.stop();
+        if (handler instanceof SubprocessHandler) await handler.close();
+        process.exit(0);
+      };
+      process.on("SIGINT", () => void shutdown("SIGINT"));
+      process.on("SIGTERM", () => void shutdown("SIGTERM"));
+
+      relay.on("connected", () => {
+        process.stderr.write(
+          JSON.stringify({ event: "connected", agent_id: merged.agentId }) + "\n",
+        );
+      });
+      relay.on("disconnected", (reason) => {
+        process.stderr.write(JSON.stringify({ event: "disconnected", reason }) + "\n");
+      });
+
+      await runtime.run();
+      process.stderr.write(JSON.stringify({ event: "provider_running", agent_id: merged.agentId }) + "\n");
+      // Keep the process alive; runtime.run() returns after initial connect.
+      await new Promise<void>(() => {});
+      } catch (err) {
+        printError(err);
+        process.exit(1);
+      }
+    });
+
+  provider
+    .command("pick <bct_id>")
+    .description("Manually accept a broadcast task (provider side)")
+    .requiredOption("--agent-id <agt_id>", "Which of your agents is accepting")
+    .option("--slot-key <key>", "Slot key for sliced broadcasts")
+    .option("--human", "Human-readable output")
+    .action(async (taskId: string, opts) => {
+      await runCommand(async () => {
+        const { providerClient } = buildContext();
+        const body: { agent_id: string; slot_key?: string } = { agent_id: opts.agentId };
+        if (opts.slotKey !== undefined) body.slot_key = opts.slotKey;
+        return providerClient.acceptGigTask(taskId, body as unknown as Record<string, unknown>);
+      }, { human: opts.human });
+    });
+
+  provider
+    .command("submit <bct_id> <result_file>")
+    .description('Submit a broadcast result. result_file = JSON path or "-" for stdin.')
+    .option("--human", "Human-readable output")
+    .action(async (taskId: string, resultFile: string, opts) => {
+      await runCommand(async () => {
+        const raw = resultFile === "-" ? await readStdin() : readFileSync(resultFile, "utf8");
+        const body = JSON.parse(raw) as BroadcastSubmitRequest;
+        const { providerClient } = buildContext();
+        return providerClient.submitGigTask(taskId, body as unknown as Record<string, unknown>);
+      }, { human: opts.human });
+    });
+}
+
+// ───── helpers ─────
+
+async function loadProviderYaml(path: string): Promise<Partial<ProviderConfig>> {
+  const raw = path === "-" ? await readStdin() : readFileSync(path, "utf8");
+  const parsed = yamlLoad(raw);
+  if (parsed === null || typeof parsed !== "object") {
+    throw new Error(`provider config ${path} is not a YAML object`);
+  }
+  return parsed as Partial<ProviderConfig>;
+}
+
+function buildCreateAgentRequest(
+  cfg: Partial<ProviderConfig>,
+): CreateAgentRequest {
+  if (!cfg.slug) throw new Error("provider config missing `slug`");
+  if (!cfg.agentName) throw new Error("provider config missing `agentName`");
+  if (!cfg.capabilities || cfg.capabilities.length === 0) {
+    throw new Error("provider config missing `capabilities`");
+  }
+  return {
+    slug: cfg.slug,
+    name: cfg.agentName,
+    description: cfg.description ?? "",
+    capabilities: cfg.capabilities,
+    ...(cfg.pricingModel !== undefined ? { pricing_model: cfg.pricingModel as CreateAgentRequest["pricing_model"] } : {}),
+    ...(cfg.priceCredits !== undefined ? { price_credits: cfg.priceCredits } : {}),
+  };
+}
+
+function makeHttpHandler(url: string): ProviderHandler {
+  return {
+    async onSessionCreate(evt) {
+      return (await postEvent(url, evt)) as { accept: boolean; reason?: string };
+    },
+    async onSessionMessage(evt) {
+      const r = await postEvent(url, evt);
+      if (r === null || r === undefined) return null;
+      if (typeof r === "string") return r;
+      if (typeof r === "object") {
+        const obj = r as Record<string, unknown>;
+        if (typeof obj["content"] === "string") return obj["content"] as string;
+        if ("payload" in obj) return obj as { payload: unknown };
+      }
+      return null;
+    },
+    async onSessionEnd(evt) {
+      await postEvent(url, evt);
+    },
+    async onInvoke(evt) {
+      return (await postEvent(url, evt)) as {
+        output?: Record<string, unknown>;
+        error?: { code: string; message: string };
+      };
+    },
+    async onBroadcastOffer(evt) {
+      return (await postEvent(url, evt)) as { accept: boolean; slot_key?: string };
+    },
+    async onBroadcastExecute(evt) {
+      return (await postEvent(url, evt)) as { result_payload?: Record<string, unknown> };
+    },
+  };
+}
+
+async function postEvent(url: string, body: object): Promise<unknown> {
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+  if (!res.ok) throw new Error(`handler HTTP ${res.status}`);
+  return res.json();
+}