@scp-dev/cli 0.2.0 → 0.2.1

package/dist/chunk-3RRPUYTE.js

@@ -1,147 +0,0 @@
-import {
-  RelayUsage
-} from "./chunk-3V3DRXB2.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-V2WT7QX5.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
-};

package/dist/chunk-3V3DRXB2.js

@@ -1,340 +0,0 @@
-import {
-  harnessLineage,
-  hiddenHarness,
-  labelsFor,
-  lineage,
-  readPsTable
-} from "./chunk-E53YHYEP.js";
-import {
-  SELF,
-  parseSeconds
-} from "./chunk-M2DCR2J4.js";
-
-// src/common.ts
-import { spawn } from "child_process";
-import { closeSync, openSync, statSync, truncateSync } from "fs";
-import { join } from "path";
-import { CLI_NAME } from "@scp-dev/core";
-import { connectBroker, privateDir, relayDir } from "@scp-dev/broker";
-var RelayUsage = class extends Error {
-};
-var OPTIONS = {
-  cloud: { type: "boolean" },
-  machine: { type: "string" },
-  token: { type: "string" },
-  label: { type: "string" },
-  "no-browser": { type: "boolean" },
-  json: { type: "boolean" },
-  channels: { type: "boolean" },
-  write: { type: "boolean" },
-  print: { type: "boolean" },
-  "block-stop-on-unread": { type: "boolean" },
-  "push-wait": { type: "string" },
-  all: { type: "boolean" },
-  as: { type: "string" },
-  harness: { type: "string" },
-  wait: { type: "string" },
-  ack: { type: "boolean" },
-  keep: { type: "boolean" },
-  "reply-to": { type: "string" },
-  "require-reply": { type: "boolean" },
-  thread: { type: "string" },
-  private: { type: "boolean" },
-  attach: { type: "string", multiple: true },
-  tool: { type: "string" },
-  summary: { type: "string" },
-  since: { type: "string" },
-  limit: { type: "string" },
-  idle: { type: "string" },
-  policy: { type: "string" },
-  human: { type: "boolean" },
-  help: { type: "boolean", short: "h" },
-  scope: { type: "string" },
-  tree: { type: "boolean" },
-  roots: { type: "boolean" },
-  contacts: { type: "boolean" },
-  activity: { type: "boolean" },
-  in: { type: "string" },
-  out: { type: "string" },
-  allow: { type: "string", multiple: true },
-  rules: { type: "string" },
-  group: { type: "string" },
-  under: { type: "string" },
-  ttl: { type: "string" },
-  labels: { type: "string" },
-  "handback-bytes": { type: "string" },
-  "no-push": { type: "boolean" },
-  bg: { type: "boolean" },
-  fg: { type: "boolean" },
-  name: { type: "string" },
-  title: { type: "string" },
-  judge: { type: "boolean" },
-  redacted: { type: "boolean" },
-  reason: { type: "string" },
-  turns: { type: "string" },
-  full: { type: "boolean" },
-  who: { type: "boolean" },
-  peek: { type: "string" }
-};
-var SPAWN_OPTIONS = [
-  "as",
-  "harness",
-  "human",
-  "name",
-  "title",
-  "scope",
-  "rules",
-  "in",
-  "out",
-  "allow",
-  "group",
-  "under",
-  "ttl",
-  "labels",
-  "peek",
-  "handback-bytes",
-  "no-push",
-  "bg",
-  "fg"
-];
-var OBSERVE = /* @__PURE__ */ new Set([
-  "list",
-  "status",
-  "watch",
-  "log",
-  "policy",
-  "machines",
-  "rules",
-  "group",
-  "admin",
-  "spawn-env",
-  "spawn",
-  "why",
-  "peek",
-  "set-peek"
-]);
-var CLOUD_OBSERVE = /* @__PURE__ */ new Set(["list", "status", "watch", "log", "machines"]);
-var GRANT_TOKEN = /^krt_[0-9a-f]{64}$/;
-var DAEMON_ENV = [
-  "PATH",
-  "LANG",
-  "LC_ALL",
-  "LC_CTYPE",
-  "TZ",
-  "TMPDIR",
-  "USER",
-  "LOGNAME",
-  "SCP_IDLE",
-  "HOME",
-  "XDG_CONFIG_HOME",
-  "SCP_TOKEN",
-  "SCP_RELAY",
-  "SCP_MACHINE"
-];
-var LOG_MAX_BYTES = 1024 * 1024;
-function startDaemon(dir) {
-  privateDir(dir);
-  const logFile = join(dir, "broker.log");
-  if ((statSync(logFile, { throwIfNoEntry: false })?.size ?? 0) > LOG_MAX_BYTES) truncateSync(logFile, 0);
-  const log = openSync(logFile, "a", 384);
-  try {
-    const env = { SCP_DIR: dir };
-    for (const key of DAEMON_ENV) if (process.env[key] !== void 0) env[key] = process.env[key];
-    const child = spawn(SELF[0], [...SELF.slice(1), "daemon"], {
-      detached: true,
-      stdio: ["ignore", log, log],
-      env,
-      cwd: dir
-    });
-    child.unref();
-  } finally {
-    closeSync(log);
-  }
-}
-function terminalAttached(streams, bodyFromStdin) {
-  if (streams.stdin.isTTY === true) return true;
-  return !bodyFromStdin && (streams.stdout.isTTY === true || streams.stderr.isTTY === true);
-}
-function localHandle(raw) {
-  const handle = raw.startsWith("me/") ? raw.slice(3) : raw;
-  if (!handle) throw new RelayUsage("--as me/ names your own human inbox: use --human");
-  if (handle.includes("/")) throw new RelayUsage(`--as names a local handle, not ${JSON.stringify(raw)}`);
-  return handle;
-}
-function walkNow() {
-  const table = readPsTable();
-  return { keys: lineage(process.ppid, table), self: harnessLineage(process.ppid, table) };
-}
-async function open(verb, values, cwd, bodyFromStdin, walk) {
-  const named = values.as ?? process.env.SCP_NAME;
-  const tty = terminalAttached(process, bodyFromStdin);
-  if (named && values.human) throw new RelayUsage("--human and --as (or $SCP_NAME) name two identities; pick one");
-  const grant = process.env.SCP_GRANT || void 0;
-  const cloud = values.cloud || process.env.SCP_TRANSPORT === "cloud" || verb === "machines";
-  if (grant !== void 0) {
-    if (!GRANT_TOKEN.test(grant)) {
-      throw new RelayUsage(
-        `$SCP_GRANT is not one spawn-env grant: pass spawn-env's lines as separate words: env $(${CLI_NAME} spawn-env ...) cmd; in zsh env \${=G} cmd`
-      );
-    }
-    if (values.human) throw new RelayUsage("--human and $SCP_GRANT name two identities: unset the grant to act as me/");
-    if (cloud) throw new RelayUsage("a spawn-env grant is for this machine's relay broker, not the cloud transport");
-  }
-  if (cloud) {
-    if (!named && !values.human && !tty && !OBSERVE.has(verb)) {
-      throw new RelayUsage(
-        `${CLI_NAME} ${verb} needs an identity: --as HANDLE (or $SCP_NAME) for an agent, or --human for your own inbox me/ (no terminal is attached, so me/ is not assumed)`
-      );
-    }
-    const { machineName, openCloud } = await import("./remote-FYN5ZXE4.js");
-    const handle2 = named ? localHandle(named) : void 0;
-    const claim = handle2 ? {
-      handle: handle2,
-      harness: values.harness ?? process.env.SCP_HARNESS ?? "cli",
-      cwd,
-      ...process.env.SCP_PARENT ? { parent: process.env.SCP_PARENT } : {},
-      labels: labelsFor(process.env, machineName(values.machine))
-    } : void 0;
-    const observe = !handle2 && !values.human && CLOUD_OBSERVE.has(verb);
-    return {
-      ...await openCloud({
-        ...values.machine !== void 0 ? { machine: values.machine } : {},
-        ...handle2 ? { handle: handle2 } : {},
-        ...claim ? { claim } : {},
-        tty,
-        observe
-      }),
-      broker: null,
-      bound: handle2 ? "as" : observe ? null : "human"
-    };
-  }
-  if (values.machine !== void 0) throw new RelayUsage("--machine names the machine of the cloud transport: add --cloud");
-  const handle = named ? localHandle(named) : void 0;
-  const { keys, self } = walk ?? walkNow();
-  const harnessPid = self.length ? Number(/^pid:(\d+)/.exec(self.at(-1))?.[1]) : void 0;
-  const lineageClaim = keys.length ? { lineage: keys } : {};
-  const dir = relayDir();
-  const client = await connectBroker(dir, () => startDaemon(dir));
-  try {
-    let bound;
-    let hello;
-    if (handle) {
-      bound = "as";
-      hello = await client.hello({
-        claim: {
-          handle,
-          exact: true,
-          harness: values.harness ?? process.env.SCP_HARNESS ?? "cli",
-          cwd,
-          ...process.env.SCP_PARENT ? { parent: process.env.SCP_PARENT } : {},
-          labels: labelsFor(process.env),
-          ...lineageClaim,
-          ...grant ? { grant } : {}
-        },
-        ...self.length ? { self } : {},
-        brief: true
-      });
-    } else if (grant) {
-      hello = await client.hello({ observe: true, ...lineageClaim, ...self.length ? { self } : {}, grant, cwd, brief: true });
-      if (!hello.grant_bound) throw new RelayUsage(`the running ${CLI_NAME} broker does not check spawn-env grants: let it exit (it stops when idle) and retry`);
-      bound = "lineage";
-    } else if (values.human || tty) {
-      hello = await client.hello({ human: true, tty, cwd, brief: true, ...lineageClaim });
-      bound = hello.endpoint?.kind === "human" ? "human" : "lineage";
-    } else {
-      hello = await client.hello({ observe: true, ...lineageClaim, ...self.length ? { self } : {}, cwd, brief: true });
-      bound = hello.endpoint ? "lineage" : null;
-      if (!hello.endpoint && !OBSERVE.has(verb)) {
-        if (hiddenHarness(process.ppid, readPsTable()))
-          throw new RelayUsage(`${CLI_NAME} ${verb}: sandbox pid namespace: this shell cannot see its harness; use the scp MCP tools`);
-        throw new RelayUsage(
-          `${CLI_NAME} ${verb}: no relay agent runs this shell's harness process (${harnessPid ? `pid ${harnessPid}` : "none found"}); pass --as HANDLE or --human (no terminal is attached, so me/ is not assumed)`
-        );
-      }
-    }
-    return { client, me: hello.endpoint, broker: hello.broker, where: brokerLine(hello.broker), bound, harnessPid };
-  } catch (error) {
-    client.close();
-    throw error;
-  }
-}
-function localClient(client, broker, verb) {
-  if (!broker) throw new RelayUsage(`${CLI_NAME} ${verb} is the local broker's; it has no --cloud form`);
-  return client;
-}
-function brokerLine(broker) {
-  const policy = broker.policy.state === "open" ? `no policy at ${broker.policy.file}, open` : broker.policy.state === "loaded" ? `policy ${broker.policy.file}` : `policy ${broker.policy.file} unusable, sends refused`;
-  return `broker ${broker.socket} (pid ${broker.pid}); ${policy}`;
-}
-function selectorList(value) {
-  if (value === void 0 || typeof value === "boolean") return void 0;
-  return (Array.isArray(value) ? value : [value]).flatMap((v) => v.split(",")).map((v) => v.trim()).filter(Boolean);
-}
-var PRESETS = /* @__PURE__ */ new Set(["open", "tree", "parent", "none"]);
-function preset(value) {
-  if (value === void 0) return void 0;
-  if (typeof value !== "string" || !PRESETS.has(value)) throw new RelayUsage("--scope takes open, tree, parent or none");
-  return value;
-}
-function peekGrant(value) {
-  if (value === void 0) return {};
-  if (value !== "local") throw new RelayUsage(`--peek takes local (peekable on this machine from its start), not ${JSON.stringify(value)}`);
-  return { peek: "local" };
-}
-function grantParams(values) {
-  const rules = selectorList(values.rules);
-  if (rules && values.scope !== void 0) throw new RelayUsage("--rules and --scope both set a preset; pick one");
-  const allow = [...rules ?? [], ...selectorList(values.allow) ?? []];
-  const scope = rules ? "none" : preset(values.scope);
-  const groups = selectorList(values.group);
-  const incoming = selectorList(values.in);
-  const outgoing = selectorList(values.out);
-  return {
-    ...values.name ? { name: values.name } : {},
-    ...values.title !== void 0 ? { title: values.title } : {},
-    ...values.under ? { under: values.under } : {},
-    ...scope ? { scope } : {},
-    ...incoming ? { in: incoming } : {},
-    ...outgoing ? { out: outgoing } : {},
-    ...allow.length ? { allow } : {},
-    ...groups?.length ? { groups } : {},
-    ...values.ttl !== void 0 ? { ttl_s: ttlSeconds(values.ttl) } : {},
-    ...values["no-push"] === true ? { no_push: true } : {},
-    ...peekGrant(values.peek)
-  };
-}
-function ttlSeconds(text) {
-  try {
-    return parseSeconds(text, "--ttl");
-  } catch (error) {
-    throw new RelayUsage(error instanceof Error ? error.message : String(error));
-  }
-}
-var pad = (n) => String(n).padStart(2, "0");
-function time(iso) {
-  const at = new Date(iso);
-  return Number.isNaN(at.getTime()) ? iso : `${pad(at.getHours())}:${pad(at.getMinutes())}:${pad(at.getSeconds())}`;
-}
-function stamp(iso) {
-  const at = new Date(iso);
-  return Number.isNaN(at.getTime()) ? iso : `${at.getFullYear()}-${pad(at.getMonth() + 1)}-${pad(at.getDate())} ${time(iso)}`;
-}
-var CHANNELS_ENV = "SCP_CHANNELS";
-
-export {
-  RelayUsage,
-  OPTIONS,
-  SPAWN_OPTIONS,
-  startDaemon,
-  walkNow,
-  open,
-  localClient,
-  brokerLine,
-  selectorList,
-  preset,
-  peekGrant,
-  grantParams,
-  time,
-  stamp,
-  CHANNELS_ENV
-};