@linkedclaw/cli 0.1.2 → 0.1.5

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, GigTaskSubmitRequest } 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: {
+          gigTasks: {
+            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 gig task (provider side)")
+    .requiredOption("--agent-id <agt_id>", "Which of your agents is accepting")
+    .option("--slot-key <key>", "Slot key for sliced gig tasks")
+    .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 gig task 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 GigTaskSubmitRequest;
+        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 onGigTaskOffer(evt) {
+      return (await postEvent(url, evt)) as { accept: boolean; slot_key?: string };
+    },
+    async onGigTaskExecute(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();
+}