@scp-dev/cli 0.1.3 → 0.2.1

package/dist/{up-VA54QWA6.js → up-2YGEDA5J.js}

@@ -1,12 +1,9 @@
 import {
+  RelayUsage,
   activeRelay,
   relayCredential
-} from "./chunk-BUC5G5PY.js";
-import {
-  RelayUsage
-} from "./chunk-URSBFDR6.js";
-import "./chunk-3PGDKPRN.js";
-import "./chunk-M2DCR2J4.js";
+} from "./chunk-ZLL5EGI2.js";
+import "./chunk-MNTIEWKF.js";
 
 // src/up.ts
 import { CLI_NAME } from "@scp-dev/core";
@@ -17,16 +14,16 @@ async function up(positionals, values, cwd, brokerStatus) {
   const { url } = activeRelay(process.env);
   const headless = values.token !== void 0 || Boolean(process.env.SCP_TOKEN?.trim());
   if (headless || !relayCredential(process.env, url).token) {
-    const code = await (await import("./login-5Y3HPSVC.js")).login({
+    const code = await (await import("./login-UB72MU7W.js")).login({
       ...values.token !== void 0 ? { token: values.token } : {},
       ...values.label !== void 0 ? { label: values.label } : {},
       ...values["no-browser"] ? { "no-browser": true } : {}
     });
     if (code !== 0) return code;
   } else out(`already logged in to ${url}`);
-  const enabled = await (await import("./remote-GC4XN44U.js")).cloudMain(["enable"], values.machine !== void 0 ? { machine: values.machine } : {}, brokerStatus);
+  const enabled = await (await import("./remote-2OWBWLJH.js")).cloudMain(["enable"], values.machine !== void 0 ? { machine: values.machine } : {}, brokerStatus);
   if (enabled !== 0) return enabled;
-  const setup = (await import("./setup-UF4AA6RO.js")).relaySetupCommand(["--write"], cwd, out);
+  const setup = (await import("./setup-HPH7HE6O.js")).relaySetupCommand(["--write"], cwd, out);
   if (setup !== 0) return setup;
   const broker = await brokerStatus();
   if (!broker.enabled) out(`the broker is still local-only; run \`${CLI_NAME} daemon restart\` to link it to ${url}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scp-dev/cli",
-  "version": "0.1.3",
+  "version": "0.2.1",
   "description": "The swarm command line tool.",
   "license": "Apache-2.0",
   "homepage": "https://scp.dev",
@@ -24,13 +24,15 @@
     "typecheck": "tsc -p ."
   },
   "dependencies": {
-    "@scp-dev/core": "0.1.1",
-    "@scp-dev/broker": "0.1.2",
-    "@scp-dev/hub": "0.1.1",
-    "@scp-dev/mcp": "0.1.2",
+    "@scp-dev/core": "0.1.2",
+    "@scp-dev/broker": "0.1.3",
+    "@scp-dev/hub": "0.2.0",
+    "@scp-dev/mcp": "0.1.3",
     "smol-toml": "^1.9.1"
   },
   "devDependencies": {
+    "@openai/codex": "0.159.0",
+    "opencode-ai": "1.18.34",
     "tsup": "^8.5.1"
   },
   "publishConfig": {

package/dist/chunk-3PGDKPRN.js

@@ -1,304 +0,0 @@
-import {
-  capture
-} from "./chunk-M2DCR2J4.js";
-
-// src/identity.ts
-import { existsSync, realpathSync } from "fs";
-import { tmpdir } from "os";
-import { basename, dirname, isAbsolute, join, resolve } from "path";
-import { shortHostname } from "@scp-dev/broker";
-import { LIMITS, validHandle, validHarness } from "@scp-dev/core";
-var SHORT = { "claude-code": "claude" };
-var SHELLS = /* @__PURE__ */ new Set(["sh", "bash", "zsh", "dash", "fish"]);
-var LABEL_KEY = /^[a-z0-9][a-z0-9._-]{0,31}$/;
-function detectHarness(env) {
-  if (env.GROK_SESSION_ID || env.GROK_HOOK_EVENT) return "grok";
-  if (env.MUSE_SESSION_ID) return "muse";
-  if (env.OPENCODE === "1") return "opencode";
-  if (env.ANTIGRAVITY_AGENT === "1" || env.ANTIGRAVITY_CONVERSATION_ID) return "agy";
-  if (env.CLAUDECODE === "1") return "claude-code";
-  if (env.CODEX_THREAD_ID) return "codex";
-  return void 0;
-}
-function normalizeHarness(raw, fallback) {
-  const name = (raw ?? "").toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+/, "").slice(0, 32).replace(/-+$/, "");
-  if (name === "claude") return "claude-code";
-  return validHarness(name) ? name : fallback;
-}
-function hookHarness(argument, env) {
-  if (!argument) return detectHarness(env) ?? "hook";
-  const named = normalizeHarness(argument, "hook");
-  return named === "claude-code" && (env.GROK_SESSION_ID || env.GROK_HOOK_EVENT) ? "grok" : named;
-}
-function resolveHarness(explicit, env, fallback) {
-  const named = explicit ?? env.SCP_HARNESS;
-  return named ? normalizeHarness(named, fallback) : detectHarness(env) ?? normalizeHarness(fallback, "mcp");
-}
-function gitToplevel(cwd) {
-  for (let dir = resolve(cwd); ; dir = dirname(dir)) {
-    if (existsSync(join(dir, ".git"))) return dir;
-    if (dirname(dir) === dir) return void 0;
-  }
-}
-function toHandle(raw) {
-  let handle = raw.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^[^a-z0-9]+/, "").slice(0, 63).replace(/[-.]+$/, "");
-  if (!handle) handle = "agent";
-  if (!validHandle(handle)) handle = `${handle.slice(0, 56)}-agent`;
-  return handle;
-}
-function deriveHandle(harness, cwd) {
-  const top = gitToplevel(cwd) ?? resolve(cwd);
-  return toHandle(`${SHORT[harness] ?? harness}-${basename(top) || "root"}`);
-}
-function parseLabels(value) {
-  const labels = {};
-  for (const pair of (value ?? "").split(",")) {
-    const eq = pair.indexOf("=");
-    const key = pair.slice(0, eq).trim();
-    if (eq > 0 && LABEL_KEY.test(key)) labels[key] = pair.slice(eq + 1).trim();
-  }
-  return labels;
-}
-function labelsFor(env, host = shortHostname()) {
-  const labels = parseLabels(env.SCP_LABELS);
-  labels.machine ??= host;
-  return labels;
-}
-function processKey(harnessPid2, startOf = psStart) {
-  const started = startOf(harnessPid2);
-  return started ? `pid:${harnessPid2}:${started}` : `pid:${harnessPid2}`;
-}
-function sessionKey(env, harnessProcess) {
-  return env.SCP_SESSION ? `env:${env.SCP_SESSION}` : harnessProcess;
-}
-function psStart(pid) {
-  try {
-    const started = (capture(["ps", "-o", "lstart=", "-p", String(pid)], { PATH: process.env.PATH ?? "/usr/bin:/bin", LC_ALL: "C" }) ?? "").trim().replace(/\s+/g, "-");
-    return /^[A-Za-z0-9:-]{1,64}$/.test(started) ? started : void 0;
-  } catch {
-    return void 0;
-  }
-}
-function parsePsCommTable(text) {
-  const table = /* @__PURE__ */ new Map();
-  for (const line of text.split("\n")) {
-    const match = /^\s*(\d+)\s+(\d+)\s+(\S+\s+\S+\s+\S+\s+\S+\s+\S+)\s+(\S.*?)\s*$/.exec(line);
-    if (match) table.set(Number(match[1]), { ppid: Number(match[2]), start: match[3].replace(/\s+/g, "-"), args: match[4] });
-  }
-  return table;
-}
-function readPsTable() {
-  try {
-    const table = capture(["ps", "-ww", "-axo", "pid=,ppid=,lstart=,args="], { PATH: process.env.PATH ?? "/usr/bin:/bin", LC_ALL: "C" });
-    return table === void 0 ? void 0 : parsePsCommTable(table);
-  } catch {
-    return void 0;
-  }
-}
-var PASS_THROUGH = /* @__PURE__ */ new Set([
-  ...SHELLS,
-  "ash",
-  "ksh",
-  "env",
-  "timeout",
-  "nohup",
-  "nice",
-  "time",
-  "stdbuf",
-  "xargs",
-  "script",
-  "caffeinate",
-  "flock",
-  "sandbox-exec",
-  "bwrap",
-  "codex-linux-sandbox",
-  "codex-linux-san"
-]);
-var INTERPRETERS = /* @__PURE__ */ new Set(["node", "nodejs", "bun", "deno", "ruby", "perl"]);
-var RUNNERS = /* @__PURE__ */ new Set(["npm", "pnpm", "yarn"]);
-var FETCHERS = /* @__PURE__ */ new Set(["npx", "bunx", "pnpx", "uvx"]);
-var SCRIPT_RUNNERS = /* @__PURE__ */ new Set(["tsx", "ts-node", "vite-node", "esno"]);
-var INLINE = /* @__PURE__ */ new Set(["-c", "-e", "--eval", "-p", "--print", "-"]);
-var VALUED = /* @__PURE__ */ new Set(["-r", "--require", "--import", "--loader", "--experimental-loader", "-I", "-M", "-W", "-X", "-C", "--conditions", "--preload"]);
-var HARNESSES = /* @__PURE__ */ new Set([
-  "claude",
-  "claude-code",
-  "codex",
-  "opencode",
-  "opencode-ai",
-  "grok",
-  "grok-cli",
-  "muse",
-  "agy",
-  "antigravity",
-  "gemini",
-  "gemini-cli"
-]);
-var INSTALLED = /(^|\/)(node_modules|site-packages|dist-packages|\.npm|\.bun|\.cache|\.local|\.cargo|\.volta|\.nvm|\.pyenv|\.rbenv|Cellar|Applications)(\/|$)|^\/(opt|usr|Library|nix)\//;
-function command(args) {
-  return basename(args.split(/\s+/)[0].replace(/^-/, "")).toLowerCase();
-}
-var namesHarness = (words) => words.some((word) => !word.startsWith("-") && word.split("/").some((part) => HARNESSES.has(part.toLowerCase().replace(/\..*$/, ""))));
-var roots;
-function workspaceRoots() {
-  if (roots) return roots;
-  const real = (path) => {
-    try {
-      return realpathSync(path);
-    } catch {
-      return path;
-    }
-  };
-  const found = [process.cwd(), tmpdir(), "/tmp", "/private/tmp", "/var/folders", "/private/var/folders"];
-  try {
-    const top = capture(["git", "rev-parse", "--show-toplevel"]);
-    if (top !== void 0) found.push(top.trim());
-  } catch {
-  }
-  roots = [...new Set(found.filter(Boolean).map(real))];
-  return roots;
-}
-function ownScript(operand) {
-  if (operand === void 0 || operand === "-") return true;
-  if (/^[a-z][a-z0-9+.-]*:/i.test(operand) || operand.startsWith("~") || INSTALLED.test(operand)) return false;
-  if (!isAbsolute(operand)) return !operand.split("/").includes("..");
-  let path = operand;
-  try {
-    path = realpathSync(operand);
-  } catch {
-  }
-  if (INSTALLED.test(path)) return false;
-  return workspaceRoots().some((root) => path === root || path.startsWith(`${root}/`));
-}
-function helper(args) {
-  const words = args.split(/\s+/);
-  if (namesHarness(words.slice(1))) return false;
-  const name = command(args);
-  let rest = words.slice(1);
-  if (FETCHERS.has(name)) {
-    while (rest[0]?.startsWith("-")) rest = rest.slice(1);
-    return SCRIPT_RUNNERS.has(rest[0] ?? "") && rest.slice(1).every((word) => word.startsWith("-") || ownScript(word));
-  }
-  if (name === "uv" || RUNNERS.has(name)) {
-    if (rest[0] !== "run") return false;
-    if (name === "uv") {
-      rest = rest.slice(1);
-      while (rest[0]?.startsWith("-")) rest = rest.slice(1);
-      if (rest[0] === void 0) return true;
-      const inner = rest.join(" ");
-      return /^python[0-9.]*$/.test(command(inner)) || INTERPRETERS.has(command(inner)) ? helper(inner) : ownScript(rest[0]);
-    }
-    return true;
-  }
-  if (!INTERPRETERS.has(name) && !/^python[0-9.]*$/.test(name)) return false;
-  if (name === "bun" && rest[0] === "x") return false;
-  if ((name === "bun" || name === "deno") && rest[0] === "run") {
-    rest = rest.slice(1);
-    if (name === "deno") while (rest[0]?.startsWith("-")) rest = rest.slice(1);
-    const target = rest.find((word) => !word.startsWith("-"));
-    if (target !== void 0 && !/[/.]/.test(target)) return false;
-  }
-  for (let i = 0; i < rest.length; i++) {
-    const word = rest[i];
-    if (word === "-m") return false;
-    if (INLINE.has(word)) return true;
-    if (VALUED.has(word)) {
-      if (!ownScript(rest[++i])) return false;
-      continue;
-    }
-    if (!word.startsWith("-")) return ownScript(word);
-  }
-  return true;
-}
-function harnessLineage(pid, table = readPsTable()) {
-  const keys = lineage(pid, table);
-  let first = -1;
-  for (let i = 0, at = pid; i < keys.length; i++, at = table.get(at).ppid) {
-    const args = table.get(at).args;
-    if (PASS_THROUGH.has(command(args))) continue;
-    if (!helper(args)) return keys.slice(0, i + 1);
-    if (first < 0) first = i;
-  }
-  return first < 0 ? [] : keys;
-}
-var INITS = /* @__PURE__ */ new Set(["init", "systemd", "launchd"]);
-function hiddenHarness(pid, table = readPsTable()) {
-  if (!table || harnessLineage(pid, table).length) return false;
-  const seen = /* @__PURE__ */ new Set();
-  let at = pid;
-  while (at > 1 && !seen.has(at)) {
-    seen.add(at);
-    const entry = table.get(at);
-    if (!entry) return false;
-    at = entry.ppid;
-  }
-  const init = table.get(1);
-  return at === 1 && init !== void 0 && !INITS.has(command(init.args));
-}
-function lineage(harnessPid2, table = readPsTable()) {
-  const keys = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (let pid = harnessPid2; pid > 1 && keys.length < LIMITS.lineageMax && !seen.has(pid); ) {
-    const entry = table?.get(pid);
-    if (!entry) break;
-    seen.add(pid);
-    keys.push(/^[A-Za-z0-9:-]{1,64}$/.test(entry.start) ? `pid:${pid}:${entry.start}` : `pid:${pid}`);
-    pid = entry.ppid;
-  }
-  return keys;
-}
-function spawnerKey(pid = process.pid, table = readPsTable()) {
-  const key = lineage(pid, table)[0];
-  return key?.startsWith(`pid:${pid}:`) ? key : void 0;
-}
-function psParent(pid) {
-  const match = /^\s*(\d+)\s+(.+?)\s*$/.exec(capture(["ps", "-o", "ppid=,comm=", "-p", String(pid)], { PATH: process.env.PATH ?? "/usr/bin:/bin" }) ?? "");
-  return match ? { ppid: Number(match[1]), comm: match[2] } : void 0;
-}
-function harnessPid(ppid = process.ppid, parentOf = psParent) {
-  const parent = parentOf(ppid);
-  if (parent && parent.ppid > 1 && SHELLS.has(basename(parent.comm.replace(/^-/, "")))) return parent.ppid;
-  return ppid;
-}
-function hookHarnessPid(env, harness, ppid = process.ppid, parentOf = psParent) {
-  const named = harness === "claude-code" ? env.CLAUDE_PID : harness === "opencode" ? env.OPENCODE_PID : void 0;
-  const pid = Number(named);
-  if (Number.isInteger(pid) && pid > 1) return pid;
-  return harnessPid(ppid, parentOf);
-}
-function relayIdentity(input) {
-  const harness = resolveHarness(input.harness, input.env, input.fallbackHarness);
-  const cwd = isAbsolute(input.cwd) ? input.cwd : resolve(input.cwd);
-  const handle = input.as ?? input.env.SCP_NAME ?? deriveHandle(harness, cwd);
-  const pid = input.harnessPid(harness);
-  const harnessProcess = processKey(pid, input.startOf);
-  const keys = input.lineageOf ? input.lineageOf(pid) : lineage(pid);
-  return {
-    handle,
-    harness,
-    cwd,
-    session: sessionKey(input.env, harnessProcess),
-    process: harnessProcess,
-    labels: labelsFor(input.env),
-    ...input.env.SCP_PARENT ? { parent: input.env.SCP_PARENT } : {},
-    ...keys.length ? { lineage: keys } : {},
-    ...input.env.SCP_GRANT ? { grant: input.env.SCP_GRANT } : {}
-  };
-}
-
-export {
-  shortHostname,
-  detectHarness,
-  hookHarness,
-  gitToplevel,
-  labelsFor,
-  readPsTable,
-  harnessLineage,
-  hiddenHarness,
-  lineage,
-  spawnerKey,
-  psParent,
-  harnessPid,
-  hookHarnessPid,
-  relayIdentity
-};

package/dist/chunk-BUC5G5PY.js

@@ -1,147 +0,0 @@
-import {
-  RelayUsage
-} from "./chunk-URSBFDR6.js";
-import {
-  note
-} from "./chunk-M2DCR2J4.js";
-
-// src/relay.ts
-import { chmodSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "fs";
-import { join, dirname } from "path";
-import { randomUUID } from "crypto";
-import { CLI_NAME } from "@scp-dev/core";
-var DEFAULT_RELAY = "https://app.scp.dev";
-function configDir(env = process.env) {
-  const base = env.XDG_CONFIG_HOME || (env.HOME ? join(env.HOME, ".config") : void 0);
-  if (!base) throw new RelayUsage("neither XDG_CONFIG_HOME nor HOME is set, so there is no place for the relay configuration");
-  return join(base, "scp");
-}
-function checkRelayUrl(text, what = "relay URL") {
-  let url;
-  try {
-    url = new URL(text);
-  } catch {
-    throw new RelayUsage(`${what} must be an absolute https URL (http is allowed only for localhost)`);
-  }
-  if (url.protocol !== "https:" && !(url.protocol === "http:" && ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname)) || url.username || url.password) {
-    throw new RelayUsage(`${what} must be an absolute https URL without credentials (http is allowed only for localhost)`);
-  }
-  return url.origin;
-}
-function readObject(path) {
-  let text;
-  try {
-    text = readFileSync(path, "utf8");
-  } catch (error) {
-    if (error.code === "ENOENT") return void 0;
-    throw new RelayUsage(`could not read ${path}`);
-  }
-  try {
-    const value = JSON.parse(text);
-    if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error();
-    return value;
-  } catch {
-    throw new RelayUsage(`${path} must contain a JSON object`);
-  }
-}
-function writePrivateJson(path, value) {
-  const dir = dirname(path);
-  mkdirSync(dir, { recursive: true, mode: 448 });
-  chmodSync(dir, 448);
-  const temp = join(dir, `.${randomUUID()}.tmp`);
-  try {
-    writeFileSync(temp, `${JSON.stringify(value, null, 2)}
-`, { mode: 384, flag: "wx" });
-    chmodSync(temp, 384);
-    renameSync(temp, path);
-  } finally {
-    rmSync(temp, { force: true });
-  }
-}
-function activeRelay(env = process.env) {
-  if (env.SCP_RELAY !== void 0) return { url: checkRelayUrl(env.SCP_RELAY, "$SCP_RELAY"), source: "SCP_RELAY" };
-  const path = join(configDir(env), "config.json");
-  const config = readObject(path);
-  if (config?.relay !== void 0) {
-    if (typeof config.relay !== "string") throw new RelayUsage(`relay in ${path} must be a URL`);
-    return { url: checkRelayUrl(config.relay, `relay in ${path}`), source: "config" };
-  }
-  return { url: DEFAULT_RELAY, source: "default" };
-}
-function readCredentials(env = process.env) {
-  const path = join(configDir(env), "credentials.json");
-  const entries = readObject(path) ?? {};
-  for (const entry of Object.values(entries)) {
-    if (!entry || typeof entry !== "object" || typeof entry.token !== "string" || !entry.token.trim() || typeof entry.saved_at !== "string") {
-      throw new RelayUsage(`${path} contains an invalid credential`);
-    }
-  }
-  return entries;
-}
-function saveCredential(env, origin, credential) {
-  const url = checkRelayUrl(origin);
-  writePrivateJson(join(configDir(env), "credentials.json"), { ...readCredentials(env), [url]: { ...credential, saved_at: (/* @__PURE__ */ new Date()).toISOString() } });
-}
-function removeCredential(env, origin) {
-  const entries = readCredentials(env);
-  const url = checkRelayUrl(origin);
-  if (!Object.hasOwn(entries, url)) return false;
-  delete entries[url];
-  writePrivateJson(join(configDir(env), "credentials.json"), entries);
-  return true;
-}
-function relayCredential(env, origin) {
-  const token = env.SCP_TOKEN?.trim();
-  if (token) return { token, source: "SCP_TOKEN", problem: null };
-  const stored = readCredentials(env)[checkRelayUrl(origin)];
-  if (stored) return { token: stored.token, source: "credentials", problem: null };
-  return { token: null, source: null, problem: `no login for ${origin}: run ${CLI_NAME} login, or set SCP_TOKEN` };
-}
-function relayVerb(positionals, asJson, env = process.env) {
-  const [action, text] = positionals;
-  if (action === "use" && text !== void 0 && positionals.length === 2) {
-    const url = checkRelayUrl(text);
-    writePrivateJson(join(configDir(env), "config.json"), { relay: url });
-    if (asJson) console.log(JSON.stringify({ url }));
-    else console.log(`saved relay ${url}`);
-    if (env.SCP_RELAY !== void 0) note("$SCP_RELAY still selects the active relay");
-    return 0;
-  }
-  if (action === "show" && positionals.length === 1) {
-    const relay = activeRelay(env);
-    const credential = relayCredential(env, relay.url);
-    const result = { ...relay, credential: credential.token ? "found" : "missing", credential_source: credential.source };
-    if (asJson) console.log(JSON.stringify(result));
-    else console.log(`${relay.url} (${relay.source}); credential ${result.credential}${credential.source ? ` (${credential.source})` : ""}`);
-    return 0;
-  }
-  throw new RelayUsage(`${CLI_NAME} relay takes use <url> or show`);
-}
-async function loginMain(positionals, values) {
-  if (positionals.length) throw new RelayUsage(`${CLI_NAME} login takes only flags`);
-  return (await import("./login-5Y3HPSVC.js")).login(values);
-}
-function logoutMain(positionals, asJson, env = process.env) {
-  if (positionals.length) throw new RelayUsage(`${CLI_NAME} logout takes no arguments`);
-  const { url } = activeRelay(env);
-  const removed = removeCredential(env, url);
-  if (asJson) console.log(JSON.stringify({ url, removed, env_token: !!env.SCP_TOKEN?.trim() }));
-  else console.log(removed ? `logged out of ${url}` : `no stored login for ${url}`);
-  if (env.SCP_TOKEN?.trim()) note("$SCP_TOKEN still applies");
-  return 0;
-}
-
-export {
-  DEFAULT_RELAY,
-  configDir,
-  checkRelayUrl,
-  writePrivateJson,
-  activeRelay,
-  readCredentials,
-  saveCredential,
-  removeCredential,
-  relayCredential,
-  relayVerb,
-  loginMain,
-  logoutMain
-};