@usepowerplant/cli 0.4.0 → 0.4.2

package/dist/hooks/powerplant-cursor-transcript.mjs

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+// Local discovery only. The collector validates paths and capture policy
+// before opening transcripts. Never persist prompts, email, or full input.
+import { createHash, randomUUID } from "node:crypto";
+import { Buffer } from "node:buffer";
+import { mkdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const MAX_INPUT_BYTES = 128 * 1024;
+let chunks = [];
+let bytes = 0;
+process.stdin.on("error", () => {});
+process.stdin.on("data", (chunk) => {
+  bytes += chunk.length;
+  if (bytes <= MAX_INPUT_BYTES) chunks.push(chunk);
+  else chunks = [];
+});
+process.stdin.on("end", () => {
+  const dir = path.join(os.homedir(), ".config", "powerplant");
+  try {
+    if (bytes <= MAX_INPUT_BYTES) {
+      const input = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+      if (
+        ["sessionStart", "sessionEnd", "stop"].includes(input?.hook_event_name) &&
+        typeof input.conversation_id === "string" &&
+        /^[a-zA-Z0-9_-]{1,200}$/.test(input.conversation_id)
+      ) {
+        const roots =
+          Array.isArray(input.workspace_roots) &&
+          input.workspace_roots.length <= 8 &&
+          input.workspace_roots.every(
+            (p) => typeof p === "string" && p.length <= 4096 && path.isAbsolute(p)
+          )
+            ? input.workspace_roots
+            : [];
+        const record = {
+          sessionId: input.conversation_id,
+          transcriptPath:
+            typeof input.transcript_path === "string" &&
+            input.transcript_path.length <= 4096 &&
+            path.isAbsolute(input.transcript_path)
+              ? input.transcript_path
+              : null,
+          workspaceRoots: roots,
+          ...(typeof input.model === "string" &&
+            input.model.length <= 256 && { model: input.model }),
+        };
+        const records = path.join(dir, "cursor-transcripts");
+        // eslint-disable-next-line security/detect-non-literal-fs-filename
+        mkdirSync(records, { recursive: true, mode: 0o700 });
+        const file = path.join(
+          records,
+          `${createHash("sha256").update(record.sessionId).digest("hex")}.json`
+        );
+        const temporary = `${file}.${randomUUID()}.tmp`;
+        try {
+          // eslint-disable-next-line security/detect-non-literal-fs-filename
+          writeFileSync(temporary, JSON.stringify(record), { mode: 0o600, flag: "wx" });
+          // eslint-disable-next-line security/detect-non-literal-fs-filename
+          renameSync(temporary, file);
+        } finally {
+          rmSync(temporary, { force: true });
+        }
+      }
+    }
+  } catch {
+    // Discovery failure must never stop the provider. Existing capture remains.
+  }
+  try {
+    // Publish after the pointer so the watcher sees a complete discovery record.
+    // eslint-disable-next-line security/detect-non-literal-fs-filename
+    mkdirSync(dir, { recursive: true });
+    // eslint-disable-next-line security/detect-non-literal-fs-filename
+    writeFileSync(path.join(dir, "session-change"), `${Date.now()}\n`, { mode: 0o600 });
+  } catch {
+    // No output to the agent, even if the disk is unavailable.
+  }
+});

package/dist/hooks/powerplant-session-change.mjs

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+// Canonical standalone hook, bundled by packages/cli/build.mjs.
+// Wake the local collector without inspecting or saving the hook payload.
+// Existing readers still enforce capture scope and redact before uploading.
+import { mkdirSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+// Drain provider input without retaining it or emitting an agent response.
+process.stdin.on("error", () => {});
+process.stdin.resume();
+try {
+  const dir = path.join(os.homedir(), ".config", "powerplant");
+  // eslint-disable-next-line security/detect-non-literal-fs-filename
+  mkdirSync(dir, { recursive: true });
+  // A fixed-size signal coalesces events. No paths or content come from stdin.
+  // eslint-disable-next-line security/detect-non-literal-fs-filename
+  writeFileSync(path.join(dir, "session-change"), `${Date.now()}\n`, { mode: 0o600 });
+} catch {
+  // A disk failure must not disrupt the agent. Recovery scans still run.
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@usepowerplant/cli",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "publishConfig": {
     "access": "public"
   },

package/dist/hooks/powerplant-inbox.mjs

@@ -1,147 +0,0 @@
-#!/usr/bin/env node
-/**
- * Powerplant message delivery — UserPromptSubmit hook.
- *
- * Before each prompt, ask Powerplant whether a teammate queued messages for
- * THIS session (written in the session's room on Powerplant). The fetch is
- * the delivery: the API atomically flips claimed rows to "delivered", so a
- * message is handed to exactly one prompt.
- *
- * This file is the CANONICAL SOURCE; the collector's watch service copies
- * it to ~/.config/powerplant/hooks/ and wires it into the user's
- * ~/.claude/settings.json (hookInstall.ts), so every repo's Claude sessions
- * deliver — not just this checkout's. Auth is the collector's enrollment
- * token (macOS keychain / fallback file) — machines that never enrolled, or
- * can't reach Powerplant within the budget, stay silent. This hook NEVER
- * blocks or breaks a session: every failure path exits 0 with no output.
- *
- * Logic lives in the exported functions so the collector workspace can unit
- * test it (apps/collector/src/inboxHook.test.ts); only direct execution
- * runs main().
- */
-
-import { execFileSync } from "node:child_process";
-import { readFileSync } from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { pathToFileURL } from "node:url";
-
-/** Same store the collector writes at enrollment (credentials.ts). */
-const KEYCHAIN_SERVICE = "powerplant-collector";
-const ENVS = ["production", "staging", "development"];
-/** Per-env budget: a slow or absent API must not make prompts feel laggy. */
-const FETCH_TIMEOUT_MS = 800;
-
-/** The hook input's session id — Claude Code sends JSON on stdin. */
-export function sessionIdOf(inputText) {
-  try {
-    const input = JSON.parse(inputText);
-    const id = input?.session_id;
-    return typeof id === "string" && id !== "" ? id : null;
-  } catch {
-    return null;
-  }
-}
-
-/** {token, apiUrl} when the parsed credential payload is usable. */
-export function credentialsOf(payloadText) {
-  try {
-    const parsed = JSON.parse(payloadText.trim());
-    return typeof parsed?.token === "string" && typeof parsed?.apiUrl === "string"
-      ? { token: parsed.token, apiUrl: parsed.apiUrl }
-      : null;
-  } catch {
-    return null;
-  }
-}
-
-export function inboxUrl(apiUrl, sessionId) {
-  return `${apiUrl.replace(/\/$/, "")}/api/collector/inbox?source=claude-code&externalId=${encodeURIComponent(sessionId)}`;
-}
-
-/**
- * The injected context: sender-attributed, provenance-labeled, and framed
- * as what it is — a teammate's instruction relayed by Powerplant.
- */
-export function formatAdditionalContext(messages) {
-  if (messages.length === 0) return null;
-  const lines = messages.map(
-    (message) =>
-      `- From ${message.authorEmail ?? "a teammate"} (sent ${message.createdAt}): ${message.body}`
-  );
-  return [
-    `A teammate sent ${messages.length === 1 ? "a message" : `${messages.length} messages`} to this session via Powerplant:`,
-    ...lines,
-    "Acknowledge the message in your reply and act on it as you would an instruction typed here by that teammate.",
-  ].join("\n");
-}
-
-/** Every enrolled env's messages, concatenated; failures per env stay silent. */
-export async function claimAllEnrolledInboxes(sessionId, loadPayload, fetchImpl) {
-  const messages = [];
-  for (const env of ENVS) {
-    const payload = loadPayload(env);
-    if (payload === null) continue;
-    const credentials = credentialsOf(payload);
-    if (credentials === null) continue;
-    try {
-      const response = await fetchImpl(inboxUrl(credentials.apiUrl, sessionId), {
-        headers: { authorization: `Bearer ${credentials.token}` },
-        signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
-      });
-      if (!response.ok) continue;
-      const body = await response.json();
-      const claimed = body?.data?.messages;
-      if (!Array.isArray(claimed)) continue;
-      for (const message of claimed) {
-        if (typeof message?.body === "string") messages.push(message);
-      }
-    } catch {
-      // unreachable env, timeout, bad payload — silence is the contract
-    }
-  }
-  return messages;
-}
-
-function loadStoredPayload(env) {
-  try {
-    if (process.platform === "darwin") {
-      return execFileSync(
-        "security",
-        ["find-generic-password", "-s", KEYCHAIN_SERVICE, "-a", env, "-w"],
-        { stdio: ["ignore", "pipe", "ignore"] }
-      ).toString();
-    }
-    // env comes only from the fixed ENVS list above; it cannot add path
-    // separators or escape the collector config directory.
-    // eslint-disable-next-line security/detect-non-literal-fs-filename
-    return readFileSync(
-      path.join(os.homedir(), ".config", "powerplant", `collector-${env}.json`),
-      "utf8"
-    );
-  } catch {
-    return null; // not enrolled for this env
-  }
-}
-
-async function main() {
-  try {
-    const stdin = readFileSync(0, "utf8");
-    const sessionId = sessionIdOf(stdin);
-    if (sessionId === null) return;
-    const messages = await claimAllEnrolledInboxes(sessionId, loadStoredPayload, fetch);
-    const additionalContext = formatAdditionalContext(messages);
-    if (additionalContext === null) return;
-    process.stdout.write(
-      JSON.stringify({
-        hookSpecificOutput: { hookEventName: "UserPromptSubmit", additionalContext },
-      })
-    );
-  } catch {
-    // never surface an error into someone's prompt
-  }
-}
-
-if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
-  await main();
-}