@primusclaw/connector 0.0.0-stage → 0.1.0

package/dist/terminal-hook.js

@@ -0,0 +1,206 @@
+#!/usr/bin/env node
+
+// src/terminals.ts
+import { execFileSync as execFileSync2 } from "node:child_process";
+import fs2 from "node:fs";
+import path from "node:path";
+
+// src/children.ts
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+function processStart(pid) {
+  try {
+    if (process.platform === "linux") {
+      const stat = fs.readFileSync(`/proc/${pid}/stat`, "utf8");
+      const rest = stat.slice(stat.lastIndexOf(")") + 2).split(" ");
+      return rest[19] ?? null;
+    }
+    return execFileSync("ps", ["-o", "lstart=", "-p", String(pid)], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim() || null;
+  } catch {
+    return null;
+  }
+}
+var isAlive = (pid) => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e.code === "EPERM";
+  }
+};
+
+// src/terminals.ts
+var SESSION_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var TERMINALS_DIR = "claw-connector-terminals";
+var terminalsDir = (configDir) => path.join(configDir, TERMINALS_DIR);
+var UNREADABLE_GRACE_MS = 6e4;
+var MAX_STDIN = 1 << 20;
+function localPidDomain() {
+  if (process.platform !== "linux") return null;
+  try {
+    return `linux:${fs2.readFileSync("/etc/machine-id", "utf8").trim()}:${fs2.readlinkSync("/proc/self/ns/pid")}`;
+  } catch {
+    return null;
+  }
+}
+var isObject = (x) => typeof x === "object" && x !== null && !Array.isArray(x);
+function holdsStill(row, localDomain) {
+  const foreign = row.pidDomain !== null && localDomain !== null && row.pidDomain !== localDomain;
+  if (foreign) return { open: true, foreign };
+  if (!isAlive(row.pid)) return { open: false, foreign };
+  if (row.procStart !== null && processStart(row.pid) !== row.procStart) return { open: false, foreign };
+  return { open: true, foreign };
+}
+function parseRow(doc) {
+  if (!isObject(doc) || doc.v !== 1) return null;
+  if (typeof doc.pid !== "number" || !Number.isInteger(doc.pid) || doc.pid <= 1) return null;
+  if (typeof doc.sessionId !== "string" || !SESSION_ID_RE.test(doc.sessionId)) return null;
+  return {
+    v: 1,
+    pid: doc.pid,
+    sessionId: doc.sessionId.toLowerCase(),
+    procStart: typeof doc.procStart === "string" && doc.procStart ? doc.procStart : null,
+    cwd: typeof doc.cwd === "string" ? doc.cwd : "",
+    at: typeof doc.at === "number" ? doc.at : 0,
+    pidDomain: typeof doc.pidDomain === "string" ? doc.pidDomain : null
+  };
+}
+function ancestorsOf(pid, max) {
+  const out = [];
+  let p = pid;
+  for (let i = 0; i < max && p > 1; i++) {
+    out.push(p);
+    let parent = 0;
+    try {
+      if (process.platform === "linux") {
+        const stat = fs2.readFileSync(`/proc/${p}/stat`, "utf8");
+        parent = Number(stat.slice(stat.lastIndexOf(")") + 2).split(" ")[1]);
+      } else {
+        parent = Number(execFileSync2("ps", ["-o", "ppid=", "-p", String(p)], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim());
+      }
+    } catch {
+      break;
+    }
+    if (!Number.isInteger(parent) || parent <= 1) break;
+    p = parent;
+  }
+  return out;
+}
+function commOfProcess(pid) {
+  try {
+    if (process.platform === "linux") return fs2.readFileSync(`/proc/${pid}/comm`, "utf8").trim() || null;
+    return path.basename(execFileSync2("ps", ["-o", "comm=", "-p", String(pid)], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim()) || null;
+  } catch {
+    return null;
+  }
+}
+function claudePid(env, ppid, deps) {
+  const chain = (deps.ancestors ?? ancestorsOf)(ppid, 8);
+  const fromEnv = Number(env.CLAUDE_PID);
+  if (Number.isInteger(fromEnv) && fromEnv > 1 && (chain.length === 0 ? isAlive(fromEnv) : chain.includes(fromEnv))) return fromEnv;
+  const comm = deps.commOf ?? commOfProcess;
+  for (const p of chain) if (comm(p) === "claude") return p;
+  return null;
+}
+function writeRow(dir, row) {
+  fs2.mkdirSync(dir, { recursive: true, mode: 448 });
+  const file = path.join(dir, `${row.pid}.json`);
+  const tmp = `${file}.${process.pid}.tmp`;
+  fs2.writeFileSync(tmp, JSON.stringify(row) + "\n", { mode: 384 });
+  fs2.renameSync(tmp, file);
+}
+function prune(dir, localDomain, now) {
+  let names;
+  try {
+    names = fs2.readdirSync(dir);
+  } catch {
+    return;
+  }
+  for (const name of names) {
+    const file = path.join(dir, name);
+    try {
+      if (name.endsWith(".tmp")) {
+        if (now - fs2.statSync(file).mtimeMs > UNREADABLE_GRACE_MS) fs2.rmSync(file, { force: true });
+        continue;
+      }
+      if (!name.endsWith(".json")) continue;
+      const row = parseRow(JSON.parse(fs2.readFileSync(file, "utf8")));
+      if (row && !holdsStill(row, localDomain).open) fs2.rmSync(file, { force: true });
+    } catch {
+    }
+  }
+}
+function runHook(i, deps = {}) {
+  let doc;
+  try {
+    doc = JSON.parse(i.stdin);
+  } catch {
+    return { done: "ignored", why: "stdin is not JSON" };
+  }
+  if (!isObject(doc) || typeof doc.session_id !== "string" || !SESSION_ID_RE.test(doc.session_id)) return { done: "ignored", why: "no session id" };
+  const sessionId = doc.session_id.toLowerCase();
+  const dir = terminalsDir(i.configDir);
+  const localDomain = deps.localDomain !== void 0 ? deps.localDomain : localPidDomain();
+  const now = (deps.now ?? Date.now)();
+  if (i.event === "start") {
+    const entry = i.env.CLAUDE_CODE_ENTRYPOINT;
+    if (entry !== "cli" && !(entry === void 0 && i.env.CLAUDE_CODE_SESSION_ATTENDED === "1")) return { done: "ignored", why: `not a terminal session (entrypoint ${entry ?? "unset"})` };
+    if (i.env.CLAUDE_CODE_SESSION_ATTENDED === "0") return { done: "ignored", why: "unattended session" };
+    const pid2 = claudePid(i.env, i.ppid, deps);
+    if (pid2 === null) return { done: "ignored", why: "cannot tell which process is claude" };
+    const procStart = processStart(pid2);
+    if (procStart === null) return { done: "ignored", why: `cannot read the start time of pid ${pid2}` };
+    writeRow(dir, { v: 1, pid: pid2, procStart, sessionId, cwd: typeof doc.cwd === "string" ? doc.cwd.slice(0, 1024) : "", at: now, pidDomain: localDomain });
+    prune(dir, localDomain, now);
+    return { done: "registered" };
+  }
+  const pid = claudePid(i.env, i.ppid, deps);
+  let removed = false;
+  if (pid !== null) {
+    const file = path.join(dir, `${pid}.json`);
+    try {
+      const row = parseRow(JSON.parse(fs2.readFileSync(file, "utf8")));
+      if (row?.sessionId === sessionId) {
+        fs2.rmSync(file, { force: true });
+        removed = true;
+      }
+    } catch {
+    }
+  }
+  prune(dir, localDomain, now);
+  return removed ? { done: "unregistered" } : { done: "ignored", why: "no row to remove" };
+}
+function readStdin(stream, ms = 1500) {
+  return new Promise((resolve) => {
+    let buf = "";
+    const done = () => {
+      clearTimeout(timer);
+      resolve(buf);
+    };
+    const timer = setTimeout(done, ms);
+    stream.setEncoding?.("utf8");
+    stream.on("data", (c) => {
+      if (buf.length < MAX_STDIN) buf += c;
+    });
+    stream.on("end", done);
+    stream.on("error", done);
+  });
+}
+
+// src/terminal-hook.ts
+async function main() {
+  const [event, flag, dir] = process.argv.slice(2);
+  if (event !== "start" && event !== "end" || flag !== "--dir" || !dir) {
+    process.stderr.write("usage: terminal-hook start|end --dir <Claude config dir>\n");
+    return;
+  }
+  const stdin = await readStdin(process.stdin);
+  const r = runHook({ event, configDir: dir, stdin, env: process.env, ppid: process.ppid });
+  if (process.env.CLAW_CONNECTOR_HOOK_DEBUG) process.stderr.write(`terminal-hook ${event}: ${r.done}${r.why ? ` (${r.why})` : ""}
+`);
+}
+main().then(() => process.exit(0), (e) => {
+  process.stderr.write(`terminal-hook: ${e instanceof Error ? e.message : String(e)}
+`);
+  process.exit(0);
+});

package/package.json

@@ -1,6 +1,35 @@
-{
-  "name": "@primusclaw/connector",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+{
+  "name": "@primusclaw/connector",
+  "version": "0.1.0",
+  "description": "Connects the coding agents on your own machine to Claw, over outbound HTTPS only.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AMD-AGI/PrimusClaw.git",
+    "directory": "connector"
+  },
+  "homepage": "https://github.com/AMD-AGI/PrimusClaw/tree/main/connector#readme",
+  "bugs": { "url": "https://github.com/AMD-AGI/PrimusClaw/issues" },
+  "type": "module",
+  "bin": { "claw-connector": "dist/cli.js" },
+  "files": ["dist", "README.md", "LICENSE"],
+  "engines": { "node": ">=22" },
+  "publishConfig": { "access": "public" },
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "typecheck": "tsc --noEmit",
+    "test": "tsx --test test/*.test.ts",
+    "prepack": "npm run build"
+  },
+  "dependencies": {
+    "@agentclientprotocol/sdk": "^2.1.0",
+    "smol-toml": "^1.9.1",
+    "zod": "^4.6.5"
+  },
+  "devDependencies": {
+    "@types/node": "^26.6.3",
+    "esbuild": "^0.28.2",
+    "tsx": "^4.23.15",
+    "typescript": "^7.0.2"
+  }
+}