copyrun 0.0.0-stage → 0.2.0

package/dist/nudge.js

@@ -0,0 +1,441 @@
+#!/usr/bin/env node
+
+// src/nudge-hook.ts
+import { spawn } from "child_process";
+import { closeSync as closeSync2, existsSync as existsSync2, fstatSync, openSync as openSync2, readFileSync as readFileSync3, readSync as readSync2, renameSync as renameSync2, writeFileSync as writeFileSync2, writeSync } from "fs";
+import { homedir } from "os";
+import { dirname, join as join3 } from "path";
+import { fileURLToPath } from "url";
+
+// src/nudge-logic.ts
+var NUDGE_STATE_FILE = "nudged.json";
+var MAX_TRANSCRIPT_BYTES = 4 * 1024 * 1024;
+var NUDGE_COOLDOWN_MS = 30 * 60 * 1e3;
+var NUDGE_MAX_SESSIONS = 500;
+var MIN_TOOL_CALLS = 8;
+var MIN_FILES_CHANGED = 1;
+var WRITE_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
+function analyzeTranscript(text) {
+  const ids = /* @__PURE__ */ new Set();
+  const files = /* @__PURE__ */ new Set();
+  let anon = 0;
+  const re = /"type"\s*:\s*"tool_use"/g;
+  for (let m = re.exec(text); m; m = re.exec(text)) {
+    const end = text.indexOf("\n", m.index);
+    const win = text.slice(m.index, Math.min(end === -1 ? text.length : end, m.index + 2e3));
+    const id = win.match(/"id"\s*:\s*"([^"\\]+)"/)?.[1];
+    if (id) {
+      if (ids.has(id)) continue;
+      ids.add(id);
+    } else anon++;
+    const name = win.match(/"name"\s*:\s*"([^"\\]+)"/)?.[1];
+    if (name && WRITE_TOOLS.has(name)) {
+      const path = win.match(/"(?:file_path|notebook_path)"\s*:\s*"((?:[^"\\]|\\.)*)"/)?.[1];
+      files.add(path ?? `#${id ?? anon}`);
+    }
+  }
+  return { toolCalls: ids.size + anon, filesChanged: files.size };
+}
+function isSubstantial(s, minTools = MIN_TOOL_CALLS, minFiles = MIN_FILES_CHANGED) {
+  return s.toolCalls >= minTools && s.filesChanged >= minFiles;
+}
+function skillsUsed(text) {
+  const out = [];
+  const add = (n) => {
+    if (!n || !/^[A-Za-z0-9._-]{1,100}$/.test(n) || n === "." || n === "..") return;
+    const i = out.indexOf(n);
+    if (i !== -1) out.splice(i, 1);
+    out.push(n);
+  };
+  const re = /"type"\s*:\s*"tool_use"/g;
+  for (let m = re.exec(text); m; m = re.exec(text)) {
+    const end = text.indexOf("\n", m.index);
+    const win = text.slice(m.index, Math.min(end === -1 ? text.length : end, m.index + 2e3));
+    if (/"name"\s*:\s*"Skill"/.test(win)) add(win.match(/"skill"\s*:\s*"([^"\\]+)"/)?.[1]?.split(":").pop());
+    for (const p of win.matchAll(/skills(?:\/|\\\\)+([A-Za-z0-9._-]+)(?:\/|\\\\)+SKILL\.md/g)) add(p[1]);
+  }
+  return out;
+}
+function recipeToAsk(used, state) {
+  const asked = new Set(state.asked ?? []);
+  return [...used].reverse().find((u) => /^[2-9a-z]{6,16}$/.test(u.runId) && !asked.has(u.runId));
+}
+function recordAsked(state, runId, cap = NUDGE_MAX_SESSIONS) {
+  return { ...state, asked: [...(state.asked ?? []).filter((r) => r !== runId), runId].slice(-cap) };
+}
+function feedbackMessage(r, s) {
+  const clean = r.title.replace(/[\u0000-\u001f\u007f-\u009f​-‏‪-‮⁠-⁤⁦-⁩]/g, "");
+  const title = clean.length > 60 ? clean.slice(0, 59) + "\u2026" : clean;
+  return `\u{1F9EA} You used "${title}" from copyrun (${s.filesChanged} file${s.filesChanged === 1 ? "" : "s"} changed). Did it work? npx copyrun worked ${r.runId} \xB7 npx copyrun failed ${r.runId}`;
+}
+function preCheck(input) {
+  if (input.stopHookActive) return "stop-hook-active";
+  if (!input.enabled) return "disabled";
+  if (!input.sessionId) return "no-session";
+  if (input.state.sessions?.includes(input.sessionId)) return "already-nudged";
+  const last = input.state.last ?? 0;
+  if (last <= input.now && input.now - last < (input.cooldownMs ?? NUDGE_COOLDOWN_MS)) return "cooldown";
+  return void 0;
+}
+function recordNudge(state, sessionId, now, cap = NUDGE_MAX_SESSIONS) {
+  const sessions = [...(state.sessions ?? []).filter((s) => s !== sessionId), sessionId].slice(-cap);
+  return { ...state, last: now, sessions };
+}
+function nudgeEnabled(config) {
+  return !(config && typeof config === "object" && config.nudge === false);
+}
+function nudgeMessage(s) {
+  const calls = `${s.toolCalls} tool call${s.toolCalls === 1 ? "" : "s"}`;
+  const files = `${s.filesChanged} file${s.filesChanged === 1 ? "" : "s"} changed`;
+  return `\u2728 Good run (${calls}, ${files}). Share it: npx copyrun share \xB7 stop these: npx copyrun nudge off`;
+}
+function hookOutput(message) {
+  return JSON.stringify({ systemMessage: message });
+}
+
+// src/managed.ts
+import { execFileSync } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+var GATED_CAPABILITIES = ["shell", "install", "network", "settings"];
+var SLUG = /^[a-z0-9][a-z0-9-]{0,39}$/;
+var HANDLE = /^[a-z0-9][a-z0-9-]{0,38}$/;
+function parseManaged(v) {
+  const problems = [];
+  const config = {};
+  if (!v || typeof v !== "object" || Array.isArray(v)) return { config, problems: ["not a JSON object"] };
+  const o = v;
+  const bool = (k) => {
+    if (o[k] === void 0) return;
+    if (typeof o[k] !== "boolean") problems.push(`${k} must be true or false`);
+    else config[k] = o[k];
+  };
+  if (o.apiHost !== void 0) {
+    try {
+      const u = new URL(String(o.apiHost));
+      const local = u.hostname === "localhost" || u.hostname === "127.0.0.1";
+      if (u.protocol !== "https:" && !(local && u.protocol === "http:")) problems.push("apiHost must be an https URL");
+      else config.apiHost = u.origin;
+    } catch {
+      problems.push("apiHost must be a URL");
+    }
+  }
+  if (o.org !== void 0) {
+    const s = typeof o.org === "string" ? o.org.trim().toLowerCase() : "";
+    if (!SLUG.test(s)) problems.push("org must be an org slug");
+    else config.org = s;
+  }
+  for (const k of ["forbidPublic", "forbidAnonymous", "forbidUnlisted", "requireShape", "disableNudge", "disableLive", "disableReceipts", "disableAutopilot", "copyLink", "disableAsk", "disableMission", "disableCopy"]) bool(k);
+  if (o.autopilotOrg !== void 0) {
+    const s = typeof o.autopilotOrg === "string" ? o.autopilotOrg.trim().toLowerCase() : "";
+    if (!SLUG.test(s)) problems.push("autopilotOrg must be an org slug");
+    else config.autopilotOrg = s;
+  }
+  if (o.autopilotContent !== void 0) {
+    if (o.autopilotContent !== "full" && o.autopilotContent !== "actions" && o.autopilotContent !== "commands") problems.push('autopilotContent must be "full", "actions" or "commands"');
+    else config.autopilotContent = o.autopilotContent;
+  }
+  if (o.allowedCloneSources !== void 0) {
+    const a = o.allowedCloneSources;
+    if (a === "any" || a === "org-playbook") config.allowedCloneSources = a;
+    else if (Array.isArray(a) && a.every((x) => typeof x === "string" && HANDLE.test(x.trim().replace(/^@/, "").toLowerCase())))
+      config.allowedCloneSources = [...new Set(a.map((x) => x.trim().replace(/^@/, "").toLowerCase()))];
+    else problems.push('allowedCloneSources must be "any", "org-playbook" or a list of handles and org slugs');
+  }
+  if (o.extraRedactTerms !== void 0) {
+    if (!Array.isArray(o.extraRedactTerms) || !o.extraRedactTerms.every((t) => typeof t === "string")) problems.push("extraRedactTerms must be a list of strings");
+    else config.extraRedactTerms = [...new Set(o.extraRedactTerms.map((t) => t.trim()).filter((t) => t.length >= 2 && t.length <= 100))].slice(0, 200);
+  }
+  if (o.profile !== void 0) {
+    if (o.profile !== "finance" && o.profile !== "hipaa") problems.push('profile must be "finance" or "hipaa"');
+    else config.profile = o.profile;
+  }
+  if (o.archive !== void 0) {
+    const a = o.archive;
+    const org = a && typeof a.org === "string" ? a.org.trim().toLowerCase() : "";
+    if (!a || typeof a !== "object" || !SLUG.test(org) || a.required !== void 0 && typeof a.required !== "boolean") problems.push("archive must be { org: <slug>, required: true|false }");
+    else config.archive = { org, required: a.required === true };
+  }
+  if (o.restrictOrgs !== void 0) {
+    const list = typeof o.restrictOrgs === "string" ? o.restrictOrgs.split(",") : o.restrictOrgs;
+    if (!Array.isArray(list) || !list.every((x) => typeof x === "string" && SLUG.test(x.trim().toLowerCase()))) problems.push("restrictOrgs must be a list of org slugs");
+    else config.restrictOrgs = [...new Set(list.map((x) => x.trim().toLowerCase()))];
+  }
+  if (o.restrictMode !== void 0) {
+    if (o.restrictMode !== "block-all-uploads") problems.push('restrictMode must be "block-all-uploads"');
+    else config.restrictMode = o.restrictMode;
+  }
+  if (o.askBefore !== void 0) {
+    if (!Array.isArray(o.askBefore) || !o.askBefore.every((t) => typeof t === "string")) problems.push("askBefore must be a list of change areas and path patterns");
+    else config.askBefore = [...new Set(o.askBefore.map((t) => t.trim()).filter((t) => t && t.length <= 200))].slice(0, 50);
+  }
+  if (o.askTimeoutMinutes !== void 0) {
+    const n = o.askTimeoutMinutes;
+    if (typeof n !== "number" || !Number.isFinite(n) || n < 1 || n > 15) problems.push("askTimeoutMinutes must be a number from 1 to 15");
+    else config.askTimeoutMinutes = Math.round(n);
+  }
+  if (o.askOrg !== void 0) {
+    const s = typeof o.askOrg === "string" ? o.askOrg.trim().toLowerCase() : "";
+    if (!SLUG.test(s)) problems.push("askOrg must be an org slug");
+    else config.askOrg = s;
+  }
+  if (o.allowCloneYesWith !== void 0) {
+    const l = o.allowCloneYesWith;
+    if (!Array.isArray(l) || !l.every((x) => GATED_CAPABILITIES.includes(x))) problems.push('allowCloneYesWith must list only "shell", "install", "network" and/or "settings"');
+    else config.allowCloneYesWith = [...new Set(l)];
+  }
+  return { config, problems };
+}
+function systemManagedPaths(platform = process.platform, env = process.env) {
+  if (platform === "darwin")
+    return [
+      { path: "/Library/Application Support/copyrun/managed.json", kind: "json" },
+      // a configuration profile (Jamf, Kandji, Intune for Mac) lands here; it wins over the file
+      { path: "/Library/Managed Preferences/ai.copyrun.cli.plist", kind: "plist" }
+    ];
+  if (platform === "win32") return [{ path: join(env.ProgramData || env.PROGRAMDATA || "C:\\ProgramData", "copyrun", "managed.json"), kind: "json" }];
+  return [{ path: "/etc/copyrun/managed.json", kind: "json" }];
+}
+function plutil(p) {
+  try {
+    return execFileSync("/usr/bin/plutil", ["-convert", "json", "-o", "-", p], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 5e3 });
+  } catch {
+    return void 0;
+  }
+}
+function loadManaged(deps = {}) {
+  const env = deps.env ?? process.env;
+  const exists = deps.exists ?? existsSync;
+  const read = deps.read ?? ((p) => readFileSync(p, "utf8"));
+  const plist = deps.plistToJson ?? plutil;
+  const system = systemManagedPaths(deps.platform ?? process.platform, env).filter((f) => exists(f.path));
+  const files = system.length ? system : env.COPYRUN_MANAGED_CONFIG ? [{ path: env.COPYRUN_MANAGED_CONFIG, kind: "json" }] : [];
+  const state = { config: {}, sources: [], errors: [] };
+  for (const f of files) {
+    let text;
+    try {
+      text = f.kind === "plist" ? plist(f.path) : read(f.path);
+    } catch (e) {
+      state.errors.push(`${f.path}: can't be read (${e.message})`);
+      continue;
+    }
+    if (text === void 0) {
+      if (f.kind === "plist" && files.some((x) => x.kind === "json")) continue;
+      state.errors.push(`${f.path}: can't be read (plutil unavailable)`);
+      continue;
+    }
+    let json;
+    try {
+      json = JSON.parse(text);
+    } catch {
+      state.errors.push(`${f.path}: not valid JSON`);
+      continue;
+    }
+    const { config, problems } = parseManaged(json);
+    if (problems.length) state.errors.push(`${f.path}: ${problems.join("; ")}`);
+    state.config = { ...state.config, ...config };
+    state.sources.push(f.path);
+  }
+  if (state.config.allowedCloneSources === "org-playbook" && !state.config.org) state.errors.push('allowedCloneSources "org-playbook" needs org');
+  if (state.config.autopilotOrg && state.config.org && state.config.autopilotOrg !== state.config.org) state.errors.push("autopilotOrg must be the same org as org");
+  if (state.config.askOrg && state.config.org && state.config.askOrg !== state.config.org) state.errors.push("askOrg must be the same org as org");
+  return state;
+}
+var cached;
+function managed() {
+  return cached ??= loadManaged();
+}
+
+// src/session-seal.ts
+import { createHash, createPrivateKey, sign } from "crypto";
+import { closeSync, mkdirSync, openSync, readdirSync, readFileSync as readFileSync2, readSync, renameSync, statSync, unlinkSync, writeFileSync } from "fs";
+import { join as join2 } from "path";
+var SEAL_QUEUE_DIR = "seal-queue";
+var SEAL_LOG_FILE = "session-seals.json";
+var SEAL_WORKER_SCRIPT = "seal-worker.mjs";
+var SEAL_SPAWN_FILE = "seal-spawn.json";
+var HOOK_MAX_BYTES = 64 * 1024 * 1024;
+var SEAL_SPAWN_THROTTLE_MS = 5 * 60 * 1e3;
+var sessionSealMessage = (hex) => `copyrun-session-v1:${hex}`;
+function readJson(path) {
+  try {
+    return JSON.parse(readFileSync2(path, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function writeJsonAtomic(path, value) {
+  const tmp = `${path}.${process.pid}.tmp`;
+  writeFileSync(tmp, JSON.stringify(value), { mode: 384 });
+  renameSync(tmp, path);
+}
+var safe = (s) => s.replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 120) || "unknown";
+function deviceOf(dir) {
+  const d = readJson(join2(dir, "config.json"))?.device;
+  return d && typeof d.privateKey === "string" && typeof d.token === "string" && typeof d.api === "string" ? d : void 0;
+}
+function sealingEnabled(dir) {
+  const cfg = readJson(join2(dir, "config.json"));
+  if (!cfg || cfg.sealSessions === false) return false;
+  return cfg.sealSessions === true || !!cfg.archive;
+}
+function fileSha256(path, max = Infinity) {
+  let fd;
+  try {
+    const st = statSync(path);
+    if (!st.isFile() || st.size > max) return void 0;
+    fd = openSync(path, "r");
+  } catch {
+    return void 0;
+  }
+  try {
+    const h = createHash("sha256");
+    const buf = Buffer.alloc(1 << 20);
+    let bytes = 0;
+    for (; ; ) {
+      const n = readSync(fd, buf, 0, buf.length, null);
+      if (!n) break;
+      h.update(buf.subarray(0, n));
+      bytes += n;
+    }
+    return { sha256: h.digest("hex"), bytes };
+  } catch {
+    return void 0;
+  } finally {
+    closeSync(fd);
+  }
+}
+function readSealLog(dir) {
+  const v = readJson(join2(dir, SEAL_LOG_FILE));
+  return Array.isArray(v) ? v.filter((e) => e && typeof e.sha256 === "string") : [];
+}
+var signWith = (message, privateKeyPem) => sign(null, Buffer.from(message, "utf8"), createPrivateKey(privateKeyPem)).toString("base64");
+function queueSeal(dir, r, now = Date.now()) {
+  const qdir = join2(dir, SEAL_QUEUE_DIR);
+  mkdirSync(qdir, { recursive: true, mode: 448 });
+  const name = `${r.kind}-${safe(r.kind === "session" && r.sessionId ? r.sessionId : r.sha256)}.json`;
+  const at = new Date(now).toISOString();
+  writeJsonAtomic(join2(qdir, name), { v: 1, ...r, createdAt: at, attempts: 0, nextAttemptAt: at });
+  return join2(qdir, name);
+}
+function queueSessionSeal(dir, s) {
+  if (!s.force && !sealingEnabled(dir)) return { queued: false, reason: "disabled" };
+  const device = deviceOf(dir);
+  if (!device) return { queued: false, reason: "not-logged-in" };
+  const f = fileSha256(s.transcriptPath, s.maxBytes ?? HOOK_MAX_BYTES);
+  if (!f) return { queued: false, reason: "unreadable" };
+  if (readSealLog(dir).some((e) => e.kind === "session" && e.sha256 === f.sha256 && e.api === device.api)) return { queued: false, reason: "already-sealed" };
+  const path = queueSeal(
+    dir,
+    { kind: "session", sha256: f.sha256, bytes: f.bytes, sessionId: s.sessionId, tool: s.tool, signature: signWith(sessionSealMessage(f.sha256), device.privateKey), publicKey: device.publicKey, api: device.api },
+    s.now
+  );
+  return { queued: true, sha256: f.sha256, bytes: f.bytes, path };
+}
+function sealSpawnDue(dir, now, always = false) {
+  const path = join2(dir, SEAL_SPAWN_FILE);
+  const last = readJson(path)?.at ?? 0;
+  if (!always && last <= now && now - last < SEAL_SPAWN_THROTTLE_MS) return false;
+  try {
+    writeJsonAtomic(path, { at: now });
+  } catch {
+  }
+  return true;
+}
+
+// src/nudge-hook.ts
+var DIR = dirname(fileURLToPath(import.meta.url));
+function readJson2(path) {
+  try {
+    return JSON.parse(readFileSync3(path, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function readTail(path, max) {
+  const fd = openSync2(path, "r");
+  try {
+    const size = fstatSync(fd).size;
+    const len = Math.min(size, max);
+    const buf = Buffer.alloc(len);
+    readSync2(fd, buf, 0, len, size - len);
+    return buf.toString("utf8");
+  } finally {
+    closeSync2(fd);
+  }
+}
+function readStdin() {
+  return new Promise((resolve) => {
+    let data = "";
+    const t = setTimeout(() => resolve(data), 1500);
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (d) => {
+      data += d;
+      if (data.length > 1e6) process.stdin.destroy();
+    });
+    process.stdin.on("end", () => (clearTimeout(t), resolve(data)));
+    process.stdin.on("error", () => (clearTimeout(t), resolve(data)));
+  });
+}
+function sealSession(transcriptPath, sessionId) {
+  if (!transcriptPath) return;
+  try {
+    const r = queueSessionSeal(DIR, { transcriptPath, sessionId, tool: "claude-code" });
+    const worker = join3(DIR, SEAL_WORKER_SCRIPT);
+    if (!r.queued || !existsSync2(worker) || !sealSpawnDue(DIR, Date.now())) return;
+    const child = spawn(process.execPath, [worker], { detached: true, stdio: "ignore", windowsHide: true, env: { ...process.env, COPYRUN_HOME: DIR } });
+    child.on("error", () => {
+    });
+    child.unref();
+  } catch {
+  }
+}
+function originsOf(names, cwd) {
+  const claude = process.env.CLAUDE_CONFIG_DIR ?? join3(homedir(), ".claude");
+  const roots = [join3(claude, "skills"), ...cwd ? [join3(cwd, ".claude", "skills")] : []];
+  const out = [];
+  for (const name of names) {
+    for (const root of roots) {
+      const o = readJson2(join3(root, name, ".origin"));
+      if (o && typeof o.runId === "string") {
+        out.push({ runId: o.runId, title: typeof o.title === "string" ? o.title : name });
+        break;
+      }
+    }
+  }
+  return out;
+}
+async function main() {
+  const input = JSON.parse(await readStdin());
+  sealSession(input.transcript_path, input.session_id);
+  const statePath = join3(DIR, NUDGE_STATE_FILE);
+  let state = readJson2(statePath) ?? {};
+  const now = Date.now();
+  const skip = preCheck({
+    sessionId: input.session_id,
+    stopHookActive: input.stop_hook_active === true,
+    // managed settings (docs/mdm.md) can turn it off for the whole machine
+    enabled: nudgeEnabled(readJson2(join3(DIR, "config.json"))) && !managed().config.disableNudge,
+    state,
+    now
+  });
+  if (skip && skip !== "already-nudged" && skip !== "cooldown" || !input.transcript_path) return;
+  const text = readTail(input.transcript_path, MAX_TRANSCRIPT_BYTES);
+  const stats = analyzeTranscript(text);
+  const ask = stats.filesChanged > 0 && !process.env.COPYRUN_REPLAY ? recipeToAsk(originsOf(skillsUsed(text), input.cwd), state) : void 0;
+  let message;
+  if (ask) {
+    state = recordAsked(state, ask.runId);
+    message = feedbackMessage(ask, stats);
+  } else if (!skip && isSubstantial(stats)) {
+    state = recordNudge(state, input.session_id, now);
+    message = nudgeMessage(stats);
+  }
+  if (!message) return;
+  const tmp = `${statePath}.${process.pid}.tmp`;
+  writeFileSync2(tmp, JSON.stringify(state), { mode: 384 });
+  renameSync2(tmp, statePath);
+  writeSync(1, hookOutput(message) + "\n");
+}
+main().catch(() => {
+}).finally(() => process.exit(0));