@pome-sh/cli 0.43.0 → 0.44.0

package/dist/twinStart-E5R26SF4.js

@@ -0,0 +1,422 @@
+import { snapshotStandaloneInitialState, updateStandaloneStatusFile } from './chunk-7ULGZG7X.js';
+export { STANDALONE_STATUS_PATH, mergeStandaloneStatus, readStandaloneStatusFile, standaloneStatusEntries, updateStandaloneStatusFile, writeStandaloneStatusFile } from './chunk-7ULGZG7X.js';
+import { readSeedFileText, seedForTwin, parseSeedFileText, soleTwinOf, twinsNamedBy } from './chunk-ZVKPZHFQ.js';
+import { bootTwin } from './chunk-3T4FUF43.js';
+import { defaultPortFor, TWIN_REGISTRY, isTwinName, TWIN_NAMES } from './chunk-RYAQ2ZYA.js';
+import './chunk-TWURH7YM.js';
+import './chunk-7VZBAHQ2.js';
+import './chunk-SG6ZTIMT.js';
+import './chunk-FBSA5L36.js';
+import { randomBytes } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { serve } from '@hono/node-server';
+import { sign } from 'hono/jwt';
+import { createServer } from 'node:net';
+
+// src/twin/connectSnippets.ts
+function mcpServerName(name) {
+  return `pome-${name}`;
+}
+function claudeCodeCommand(input) {
+  return `claude mcp add --transport http ${mcpServerName(input.name)} ${input.mcpUrl} --header "Authorization: Bearer ${input.token}"`;
+}
+function codexConfigBlock(input) {
+  return [
+    `[mcp_servers.${mcpServerName(input.name)}]`,
+    `url = "${input.mcpUrl}"`,
+    `bearer_token_env_var = "POME_AUTH_TOKEN"`
+  ].join("\n");
+}
+function mcpJsonStanzaFor(inputs) {
+  const mcpServers = {};
+  for (const input of inputs) {
+    mcpServers[mcpServerName(input.name)] = {
+      type: "http",
+      url: input.mcpUrl,
+      headers: { Authorization: "Bearer ${POME_AUTH_TOKEN}" }
+    };
+  }
+  return JSON.stringify({ mcpServers }, null, 2);
+}
+function sdkLines(input) {
+  const rest = `process.env.POME_${input.envName}_REST_URL`;
+  switch (input.name) {
+    case "github":
+      return {
+        label: "GitHub's SDK (Octokit)",
+        lines: [`new Octokit({ baseUrl: ${rest}, auth: process.env.POME_AUTH_TOKEN })`]
+      };
+    case "slack":
+      return {
+        label: "Slack's SDK (WebClient)",
+        lines: [`new WebClient(process.env.POME_AUTH_TOKEN, { slackApiUrl: ${rest} + "/" })`]
+      };
+    case "stripe":
+      return {
+        label: "Stripe's SDK",
+        lines: [
+          `new Stripe(process.env.POME_AUTH_TOKEN, { host: "127.0.0.1", port: Number(new URL(${rest}).port), protocol: "http" })`
+        ]
+      };
+    case "gmail":
+      return {
+        label: "googleapis (Gmail)",
+        lines: [
+          `const gmail = google.gmail({ version: "v1", auth }); // auth: an OAuth2 client with access_token = ${input.tokenEnvName ?? "POME_AUTH_TOKEN"}`,
+          `gmail.users.messages.list({ userId: "me" }, { rootUrl: ${rest} + "/" }); // rootUrl goes on each call`
+        ]
+      };
+    case "linear":
+      return {
+        label: "Linear's SDK",
+        lines: [
+          `new LinearClient({ apiKey: process.env.${input.tokenEnvName ?? "POME_AUTH_TOKEN"}, apiUrl: ${rest} + "/graphql" })`
+        ]
+      };
+  }
+}
+function exportLineFor(inputs) {
+  const first = inputs[0];
+  if (first === void 0) throw new Error("exportLineFor: no twins");
+  const pairs = inputs.flatMap((input) => [
+    `POME_${input.envName}_REST_URL=${input.restUrl}`,
+    `POME_${input.envName}_MCP_URL=${input.mcpUrl}`
+  ]);
+  pairs.push(`POME_AUTH_TOKEN=${first.token}`);
+  for (const input of inputs) {
+    if (input.tokenEnvName) pairs.push(`${input.tokenEnvName}=${input.token}`);
+  }
+  return `export ${pairs.join(" ")}`;
+}
+function indent(text) {
+  return text.split("\n").map((line) => `  ${line}`).join("\n");
+}
+function renderConnectSnippets(input) {
+  const inputs = Array.isArray(input) ? input : [input];
+  const sdkSections = inputs.map((twin) => {
+    const sdk = sdkLines(twin);
+    return [`Your own code, through ${sdk.label}:`, indent(sdk.lines.join("\n"))].join("\n");
+  });
+  return [
+    "Connect your agent (pick one):",
+    "",
+    "Claude Code:",
+    indent(inputs.map(claudeCodeCommand).join("\n")),
+    "",
+    "Codex, .mcp.json and the SDK line below read the token from your shell. Export it once:",
+    indent(exportLineFor(inputs)),
+    "",
+    "Codex (append to ~/.codex/config.toml):",
+    indent(inputs.map(codexConfigBlock).join("\n\n")),
+    "",
+    ".mcp.json (Claude Code project scope, in the repo):",
+    indent(mcpJsonStanzaFor(inputs)),
+    "",
+    sdkSections.join("\n\n")
+  ].join("\n");
+}
+async function isLoopbackPortFree(port) {
+  return await new Promise((resolve) => {
+    const probe = createServer();
+    probe.once("error", () => resolve(false));
+    probe.listen(port, "127.0.0.1", () => probe.close(() => resolve(true)));
+  });
+}
+async function chooseStandalonePorts(twins, portOption, env = process.env, isFree = isLoopbackPortFree) {
+  const parse = (raw) => {
+    const port = Number(raw);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+      throw new Error(`pome twin start: invalid --port "${raw}"`);
+    }
+    return port;
+  };
+  if (twins.length === 1) return [parse(portOption ?? defaultPortFor(twins[0], env))];
+  const chosen = [];
+  for (const [index, twin] of twins.entries()) {
+    if (index === 0 && portOption !== void 0) {
+      chosen.push(parse(portOption));
+      continue;
+    }
+    const start = portOption !== void 0 ? chosen[index - 1] + 1 : parse(defaultPortFor(twin, env));
+    let candidate = start;
+    while (chosen.includes(candidate) || !await isFree(candidate)) {
+      candidate += 1;
+      if (candidate > 65535 || candidate - start > 200) {
+        throw new Error(
+          `pome twin start: no free port for the ${twin} twin within 200 of ${start} \u2014 pass --port <port>.`
+        );
+      }
+    }
+    chosen.push(candidate);
+  }
+  return chosen;
+}
+
+// src/twin/twinStart.ts
+var STANDALONE_SID = "standalone";
+function resolveStandaloneAuthSecret(twin, env = process.env) {
+  const injected = env.TWIN_AUTH_SECRET;
+  if (injected) return { secret: injected, source: "env" };
+  const dataDir = env.POME_TWIN_DATA_DIR || join(".pome-data", twin);
+  const secretPath = join(dataDir, "secret");
+  let raw;
+  try {
+    raw = readFileSync(secretPath, "utf8");
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+  const persisted = raw?.trim() ?? "";
+  if (persisted.length >= 32) {
+    return { secret: persisted, source: "persisted", path: secretPath };
+  }
+  if (persisted.length > 0) {
+    throw new Error(
+      `The persisted secret at ${secretPath} is shorter than 32 chars \u2014 fix or delete the file, or inject TWIN_AUTH_SECRET.`
+    );
+  }
+  return { secret: randomBytes(32).toString("hex"), source: "ephemeral" };
+}
+async function resolveStandaloneSeed(twin, seedPath, env = process.env, seedText) {
+  if (seedPath !== void 0) {
+    const raw = seedText ?? readSeedFileText(seedPath, "pome twin start --seed");
+    const origin = `--seed ${seedPath}`;
+    return {
+      seedState: await seedForTwin(parseSeedFileText(raw, origin), twin, origin),
+      source: "file",
+      path: seedPath
+    };
+  }
+  const fromEnv = env.POME_SEED_JSON;
+  if (fromEnv !== void 0 && fromEnv !== "") {
+    return {
+      seedState: await seedForTwin(
+        parseSeedFileText(fromEnv, "POME_SEED_JSON"),
+        twin,
+        "POME_SEED_JSON"
+      ),
+      source: "env"
+    };
+  }
+  return { seedState: await TWIN_REGISTRY[twin].defaultSeed(), source: "default" };
+}
+function resolveStandaloneTwin(name, seedPath, seedText) {
+  if (name !== void 0) {
+    if (!isTwinName(name)) {
+      throw new Error(`Unknown twin '${name}'. Supported: ${TWIN_NAMES.join(", ")}.`);
+    }
+    return name;
+  }
+  if (seedPath === void 0 || seedText === void 0) {
+    throw new Error(
+      `pome twin start: name a twin (${TWIN_NAMES.join(", ")}), or pass a --seed file whose envelope names exactly one.`
+    );
+  }
+  const origin = `--seed ${seedPath}`;
+  const file = parseSeedFileText(seedText, origin);
+  const sole = soleTwinOf(file);
+  if (sole !== void 0) return sole;
+  const named = twinsNamedBy(file);
+  throw new Error(
+    named.length === 0 ? `${origin} is a flat seed, so it does not name a twin. Pass the name: pome twin start <${TWIN_NAMES.join("|")}> --seed ${seedPath}` : `${origin} names ${named.length} twins (${named.join(", ")}), so it does not say which one to start. Pass the name: pome twin start ${named[0]} --seed ${seedPath}`
+  );
+}
+function resolveStandaloneTwins(names, seedPath, seedText) {
+  if (names.length === 0) return [resolveStandaloneTwin(void 0, seedPath, seedText)];
+  const twins = [];
+  for (const name of names) {
+    if (!isTwinName(name)) {
+      throw new Error(`Unknown twin '${name}'. Supported: ${TWIN_NAMES.join(", ")}.`);
+    }
+    if (twins.includes(name)) {
+      throw new Error(
+        `pome twin start: '${name}' is named twice. Each twin boots once per command; name it once.`
+      );
+    }
+    twins.push(name);
+  }
+  return twins;
+}
+async function resolveStandaloneSeeds(twins, seedPath, env = process.env, seedText) {
+  const out = /* @__PURE__ */ new Map();
+  if (twins.length === 1) {
+    const only = twins[0];
+    out.set(only, await resolveStandaloneSeed(only, seedPath, env, seedText));
+    return out;
+  }
+  let authored;
+  if (seedPath !== void 0) {
+    authored = {
+      raw: seedText ?? readSeedFileText(seedPath, "pome twin start --seed"),
+      origin: `--seed ${seedPath}`,
+      source: "file",
+      path: seedPath
+    };
+  } else if (env.POME_SEED_JSON !== void 0 && env.POME_SEED_JSON !== "") {
+    authored = { raw: env.POME_SEED_JSON, origin: "POME_SEED_JSON", source: "env" };
+  }
+  if (authored === void 0) {
+    for (const twin of twins) {
+      out.set(twin, { seedState: await TWIN_REGISTRY[twin].defaultSeed(), source: "default" });
+    }
+    return out;
+  }
+  const file = parseSeedFileText(authored.raw, authored.origin);
+  if (file.shape === "flat") {
+    throw new Error(
+      `${authored.origin} is a flat seed for one twin, and pome twin start was given ${twins.length} names (${twins.join(", ")}), so nothing says which one it is for. Name one twin, or wrap it in a per-twin envelope: { "${twins[0]}": { \u2026 } }.`
+    );
+  }
+  for (const twin of twins) {
+    out.set(twin, {
+      seedState: await seedForTwin(file, twin, authored.origin),
+      source: authored.source,
+      ...authored.path !== void 0 ? { path: authored.path } : {}
+    });
+  }
+  return out;
+}
+function resolveStandaloneAuthSecretFor(twins, env = process.env, resolveOne = resolveStandaloneAuthSecret) {
+  if (twins.length === 1) return resolveOne(twins[0], env);
+  if (env.TWIN_AUTH_SECRET) return { secret: env.TWIN_AUTH_SECRET, source: "env" };
+  const persisted = twins.map((twin) => resolveOne(twin, env)).filter((resolved) => resolved.source === "persisted");
+  const distinct = new Set(persisted.map((resolved) => resolved.secret));
+  if (distinct.size > 1) {
+    throw new Error(
+      `pome twin start: ${persisted.map((resolved) => resolved.path).join(" and ")} hold different secrets, and one process serves one secret. Inject TWIN_AUTH_SECRET, or make the files agree.`
+    );
+  }
+  const shared = persisted[0];
+  if (shared !== void 0) return { secret: shared.secret, source: "persisted", path: shared.path };
+  return { secret: randomBytes(32).toString("hex"), source: "ephemeral" };
+}
+async function runTwinStartCommand(namesArg, options) {
+  const names = namesArg === void 0 ? [] : typeof namesArg === "string" ? [namesArg] : [...namesArg];
+  const seedText = options.seed === void 0 ? void 0 : readSeedFileText(options.seed, "pome twin start --seed");
+  const twins = resolveStandaloneTwins(names, options.seed, seedText);
+  const ports = await chooseStandalonePorts(twins, options.port, process.env);
+  const seeds = await resolveStandaloneSeeds(twins, options.seed, process.env, seedText);
+  const resolved = resolveStandaloneAuthSecretFor(twins);
+  process.env.TWIN_AUTH_SECRET = resolved.secret;
+  const booted = [];
+  try {
+    for (const [index, twin] of twins.entries()) {
+      const port = ports[index];
+      const baseUrl = `http://127.0.0.1:${port}`;
+      const harness = await bootTwin({
+        twin,
+        seedState: seeds.get(twin).seedState,
+        runId: STANDALONE_SID,
+        twinBaseUrl: baseUrl
+      });
+      booted.push({ twin, port, baseUrl, harness });
+      await snapshotStandaloneInitialState(twin, () => harness.exportState());
+    }
+  } catch (err) {
+    for (const entry of booted) await entry.harness.close();
+    throw err;
+  }
+  let extraClaims = {};
+  for (const entry of booted) extraClaims = { ...extraClaims, ...entry.harness.extraClaims ?? {} };
+  const token = await sign(
+    {
+      sid: STANDALONE_SID,
+      team_id: "tm_local",
+      login: "pome-agent",
+      ...extraClaims,
+      exp: Math.floor(Date.now() / 1e3) + 60 * 60 * 24
+    },
+    resolved.secret
+  );
+  const servers = [];
+  const closeAll = async () => {
+    for (const server of servers) {
+      server.closeAllConnections?.();
+      await new Promise((resolve) => server.close(() => resolve()));
+    }
+    for (const entry of booted) await entry.harness.close();
+  };
+  try {
+    for (const entry of booted) {
+      const server = serve({ fetch: entry.harness.app.fetch, port: entry.port, hostname: "127.0.0.1" });
+      servers.push(server);
+      await new Promise((resolve, reject) => {
+        const onError = (err) => {
+          reject(
+            err.code === "EADDRINUSE" ? new Error(
+              `pome twin start: port ${entry.port} is already in use \u2014 pass --port <port>, or stop the twin using it.`
+            ) : err
+          );
+        };
+        server.once("error", onError);
+        server.once("listening", () => {
+          server.off("error", onError);
+          server.on("error", (err) => console.error(`pome twin start: server error: ${err}`));
+          resolve();
+        });
+      });
+    }
+    const entries = booted.map((entry) => {
+      const restUrl = `${entry.baseUrl}/s/${STANDALONE_SID}`;
+      return { name: entry.twin, url: restUrl, rest_url: restUrl, mcp_url: `${restUrl}/mcp`, auth_token: token };
+    });
+    await updateStandaloneStatusFile(entries);
+  } catch (err) {
+    await closeAll();
+    throw err;
+  }
+  const connect = [];
+  for (const [index, entry] of booted.entries()) {
+    const { twin: name, port, baseUrl, harness } = entry;
+    const restUrl = `${baseUrl}/s/${STANDALONE_SID}`;
+    const mcpUrl = `${restUrl}/mcp`;
+    const world = seeds.get(name);
+    console.log(`Pome ${name} twin listening at ${restUrl}`);
+    if (world.source === "file") {
+      console.log(`Seed: ${world.path} (replaces the ${name} twin's default).`);
+    } else if (world.source === "env") {
+      console.log(
+        `Seed: POME_SEED_JSON (replaces the ${name} twin's default; --seed <path> overrides it).`
+      );
+    } else {
+      console.log(
+        `Seed: the ${name} twin's default (pass --seed <path>, or write one with \`pome twin new-seed ${name}\`).`
+      );
+    }
+    if (index === 0 && resolved.source === "persisted") {
+      console.log(
+        `Auth: using the persisted secret from ${resolved.path} (an env-injected TWIN_AUTH_SECRET overrides it).`
+      );
+    }
+    console.log(`POME_${harness.envName}_REST_URL=${restUrl}`);
+    console.log(`POME_${harness.envName}_MCP_URL=${mcpUrl}`);
+    console.log(`POME_AUTH_TOKEN=${token}`);
+    if (harness.tokenEnvName) console.log(`${harness.tokenEnvName}=${token}`);
+    console.log(`Health check (no auth): curl ${baseUrl}/healthz`);
+    connect.push({
+      name,
+      envName: harness.envName,
+      port,
+      restUrl,
+      mcpUrl,
+      token,
+      ...harness.tokenEnvName ? { tokenEnvName: harness.tokenEnvName } : {}
+    });
+  }
+  console.log("");
+  console.log(renderConnectSnippets(connect));
+  console.log("");
+  console.log("Ctrl-C to stop.");
+  const shutdown = () => {
+    void (async () => {
+      const hardExit = setTimeout(() => process.exit(1), 1e4);
+      hardExit.unref();
+      await closeAll();
+      process.exit(0);
+    })();
+  };
+  process.once("SIGINT", shutdown);
+  process.once("SIGTERM", shutdown);
+}
+
+export { chooseStandalonePorts, isLoopbackPortFree, resolveStandaloneAuthSecret, resolveStandaloneAuthSecretFor, resolveStandaloneSeed, resolveStandaloneSeeds, resolveStandaloneTwin, resolveStandaloneTwins, runTwinStartCommand };