@scp-dev/cli 0.0.0-stage → 0.1.2

package/dist/chunk-YYSLYVNZ.js

@@ -0,0 +1,38 @@
+// src/hook-fast.ts
+var SUBAGENT = "--subagent";
+var STDIN_CAP = 8 * 1024 * 1024;
+var preread;
+async function readCapped(stream) {
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of stream) {
+    const bytes = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+    const taken = bytes.subarray(0, STDIN_CAP - size);
+    chunks.push(taken);
+    size += taken.length;
+    if (size >= STDIN_CAP) break;
+  }
+  return Buffer.concat(chunks, size).toString("utf8");
+}
+function subagentSkip(argv, payload) {
+  return argv[0] === "hook" && argv.includes(SUBAGENT) && !/"agent(_id|Id)"/.test(payload);
+}
+async function subagentFastPath(argv) {
+  if (!(argv[0] === "hook" && argv.includes(SUBAGENT))) return false;
+  const payload = await readCapped(process.stdin);
+  if (subagentSkip(argv, payload)) return true;
+  preread = payload;
+  return false;
+}
+function prereadStdin() {
+  const payload = preread;
+  preread = void 0;
+  return payload;
+}
+
+export {
+  SUBAGENT,
+  readCapped,
+  subagentFastPath,
+  prereadStdin
+};

package/dist/cli.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+import {
+  subagentFastPath
+} from "./chunk-YYSLYVNZ.js";
+
+// src/warnings.ts
+function quietSqliteWarning() {
+  const emit = process.emitWarning;
+  const filtered = (warning, ...rest) => {
+    const type = typeof rest[0] === "string" ? rest[0] : rest[0]?.type;
+    if (type === "ExperimentalWarning" && /sqlite/i.test(String(warning instanceof Error ? warning.message : warning))) return;
+    emit.call(process, warning, ...rest);
+  };
+  process.emitWarning = filtered;
+}
+
+// src/cli.ts
+if (!await subagentFastPath(process.argv.slice(2))) {
+  quietSqliteWarning();
+  const { run } = await import("./main-5CAHHN55.js");
+  await run(process.argv.slice(2));
+}

package/dist/hooks-O3UZXDYG.js

@@ -0,0 +1,71 @@
+import {
+  AGY_HOOK_SET,
+  AGY_UNVERIFIED,
+  BLOCK_STOP,
+  DIRECTIVE_CLOSE,
+  HOOK_COMMAND,
+  NO_INJECT,
+  PARENT_EXCEPTION,
+  PUSH_WAIT,
+  PUSH_WAIT_DEFAULT_S,
+  REPLY_HOW,
+  agyHookSet,
+  claudeVersionFile,
+  hasOurHooks,
+  hookEntries,
+  hookReply,
+  injectionText,
+  introText,
+  mapHookPayload,
+  mergeHooks,
+  musePlugin,
+  nudgeText,
+  opencodePlugin,
+  pushText,
+  pushWait,
+  relayHookCommand,
+  runHook,
+  steerPrompt,
+  stopContinues,
+  subagentIntro,
+  summarize,
+  unreadPointer
+} from "./chunk-XWLF7ON2.js";
+import {
+  SUBAGENT
+} from "./chunk-YYSLYVNZ.js";
+import "./chunk-DA3EB2YF.js";
+export {
+  AGY_HOOK_SET,
+  AGY_UNVERIFIED,
+  BLOCK_STOP,
+  DIRECTIVE_CLOSE,
+  HOOK_COMMAND,
+  NO_INJECT,
+  PARENT_EXCEPTION,
+  PUSH_WAIT,
+  PUSH_WAIT_DEFAULT_S,
+  REPLY_HOW,
+  SUBAGENT,
+  agyHookSet,
+  claudeVersionFile,
+  hasOurHooks,
+  hookEntries,
+  hookReply,
+  injectionText,
+  introText,
+  mapHookPayload,
+  mergeHooks,
+  musePlugin,
+  nudgeText,
+  opencodePlugin,
+  pushText,
+  pushWait,
+  relayHookCommand,
+  runHook,
+  steerPrompt,
+  stopContinues,
+  subagentIntro,
+  summarize,
+  unreadPointer
+};

package/dist/install-HFBSKSTG.js

@@ -0,0 +1,14 @@
+import {
+  hooksTarget,
+  installHooks,
+  mcpInstall
+} from "./chunk-4DNQFATX.js";
+import "./chunk-7KP6TAJW.js";
+import "./chunk-XWLF7ON2.js";
+import "./chunk-YYSLYVNZ.js";
+import "./chunk-DA3EB2YF.js";
+export {
+  hooksTarget,
+  installHooks,
+  mcpInstall
+};

package/dist/login-JTRUWG6Q.js

@@ -0,0 +1,129 @@
+import {
+  machineName
+} from "./chunk-6UFMKYPH.js";
+import {
+  activeRelay,
+  saveCredential
+} from "./chunk-4QYUPPGV.js";
+import {
+  RelayUsage
+} from "./chunk-7KP6TAJW.js";
+import {
+  note
+} from "./chunk-DA3EB2YF.js";
+
+// src/login.ts
+import { spawn } from "child_process";
+import { setTimeout } from "timers/promises";
+import { CLI_NAME } from "@scp-dev/core";
+function openBrowser(url, env = process.env) {
+  if (!/^https?:\/\//.test(url) || env.SSH_CONNECTION || env.SSH_TTY || process.platform === "linux" && !env.DISPLAY && !env.WAYLAND_DISPLAY) return false;
+  const command = env.BROWSER !== void 0 ? env.BROWSER && env.BROWSER !== "none" ? env.BROWSER : void 0 : process.platform === "darwin" ? "open" : process.platform === "linux" ? "xdg-open" : void 0;
+  if (!command) return false;
+  try {
+    const child = spawn(command, [url], { detached: true, stdio: "ignore", env });
+    child.on("error", () => {
+    });
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+var WHOAMI_FIELDS = ["kind", "org", "email", "role", "label", "ambient", "endpoint_labels", "expires_at"];
+var publicWhoami = (value) => Object.fromEntries(WHOAMI_FIELDS.filter((key) => key in value).map((key) => [key, value[key]]));
+async function responseBody(response) {
+  try {
+    const body = await response.json();
+    if (body && typeof body === "object" && !Array.isArray(body)) return body;
+  } catch {
+  }
+  throw new Error("the relay returned an invalid login response");
+}
+async function login(values, env = process.env) {
+  const { url } = activeRelay(env);
+  const token = values.token !== void 0 ? values.token.trim() : env.SCP_TOKEN?.trim();
+  const done = (who) => {
+    if (values.json) console.log(JSON.stringify(publicWhoami(who)));
+    else console.log(`logged in to ${url} as ${who.email ?? "?"} in ${who.org ?? "?"}`);
+    return 0;
+  };
+  if (values.token !== void 0 && !token) throw new RelayUsage("--token needs a nonempty token");
+  if (token) {
+    let response;
+    try {
+      response = await fetch(`${url}/v1/whoami`, { headers: { Authorization: `Bearer ${token}` }, signal: AbortSignal.timeout(3e4), redirect: "error" });
+    } catch {
+      throw new Error(`could not check the token at ${url}`);
+    }
+    if (response.status === 401) throw new Error(`that token is not valid for ${url}`);
+    if (response.status !== 200) throw new Error(`could not check the token at ${url} (HTTP ${response.status})`);
+    const who = await responseBody(response);
+    saveCredential(env, url, { token, ...metadata(who) });
+    return done(who);
+  }
+  const label = machineName(values.label, env);
+  let startResponse;
+  try {
+    startResponse = await fetch(`${url}/v1/device/code`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ label }),
+      signal: AbortSignal.timeout(3e4),
+      redirect: "error"
+    });
+  } catch {
+    throw new Error(`could not start login at ${url}`);
+  }
+  const start = await responseBody(startResponse);
+  if (!startResponse.ok)
+    throw new Error(typeof start.error_description === "string" ? start.error_description : `could not start login at ${url} (HTTP ${startResponse.status})`);
+  if (typeof start.device_code !== "string" || typeof start.user_code !== "string" || typeof start.verification_uri !== "string" || typeof start.verification_uri_complete !== "string" || typeof start.expires_in !== "number" || !Number.isFinite(start.expires_in) || start.expires_in <= 0 || typeof start.interval !== "number" || !Number.isFinite(start.interval) || start.interval < 0) {
+    throw new Error("the relay returned an invalid device code");
+  }
+  const expires = Date.now() + start.expires_in * 1e3;
+  let interval = start.interval * 1e3;
+  note(`to sign in, open ${start.verification_uri_complete}`);
+  note(`and check that it shows the code ${start.user_code}`);
+  const opened = !values["no-browser"] && openBrowser(start.verification_uri_complete, env);
+  note(opened ? "opened it in your browser; waiting for approval" : "waiting for approval");
+  while (Date.now() < expires) {
+    await setTimeout(Math.min(interval, Math.max(0, expires - Date.now())));
+    if (Date.now() >= expires) break;
+    let response;
+    let body;
+    try {
+      response = await fetch(`${url}/v1/device/token`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ device_code: start.device_code }),
+        signal: AbortSignal.timeout(Math.max(1, Math.min(3e4, expires - Date.now()))),
+        redirect: "error"
+      });
+      if (response.status >= 500) continue;
+      body = await responseBody(response);
+    } catch {
+      continue;
+    }
+    if (response.ok && typeof body.access_token === "string" && body.access_token) {
+      saveCredential(env, url, { token: body.access_token, ...metadata(body), kind: "device", label: typeof body.label === "string" ? body.label : label });
+      return done({ ...body, kind: "device" });
+    }
+    if (body.error === "authorization_pending") continue;
+    if (body.error === "slow_down") {
+      interval += 5e3;
+      continue;
+    }
+    throw new Error(
+      typeof body.error_description === "string" ? body.error_description : `login failed: ${typeof body.error === "string" ? body.error : `HTTP ${response.status}`}`
+    );
+  }
+  throw new Error(`the device code expired: run ${CLI_NAME} login again`);
+}
+function metadata(who) {
+  return Object.fromEntries(["kind", "org", "email", "label"].filter((key) => typeof who[key] === "string").map((key) => [key, who[key]]));
+}
+export {
+  login,
+  openBrowser
+};