@usepowerplant/cli 0.3.0

package/dist/hooks/powerplant-inbox.mjs

@@ -0,0 +1,147 @@
+#!/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();
+}

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

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+/**
+ * Powerplant session lifecycle — SessionStart / SessionEnd hook.
+ *
+ * Claude Code fires these at real session boundaries (start, resume, clear,
+ * quit). This hook appends one line per event to a local journal
+ * (~/.config/powerplant/session-lifecycle.jsonl) so the collector's scan can
+ * mark a session "completed" the moment its SessionEnd arrives, with the
+ * observed end time — instead of waiting out the transcript-quiet grace
+ * window. The `at` stamp is when THIS process observed the hook fire; it is
+ * never a claimed or reconstructed time.
+ *
+ * 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
+ * report — not just this checkout's. 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/lifecycleHook.test.ts); only direct execution
+ * runs main().
+ */
+
+import { appendFileSync, mkdirSync, readFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+
+/** The collector's watcher and scan read this same path (lifecycleJournal.ts). */
+export function journalPath(home) {
+  return path.join(home, ".config", "powerplant", "session-lifecycle.jsonl");
+}
+
+/**
+ * One journal line from the hook's stdin JSON; null when the input isn't a
+ * lifecycle event we can attribute to a session. SessionStart carries a
+ * `source` (startup|resume|clear|compact|fork), SessionEnd a `reason`
+ * (clear|resume|logout|prompt_input_exit|other) — both land as `reason`.
+ */
+export function journalLineOf(inputText, at) {
+  try {
+    const input = JSON.parse(inputText);
+    const sessionId = input?.session_id;
+    if (typeof sessionId !== "string" || sessionId === "") return null;
+    const event =
+      input?.hook_event_name === "SessionStart"
+        ? "start"
+        : input?.hook_event_name === "SessionEnd"
+          ? "end"
+          : null;
+    if (event === null) return null;
+    const reason = event === "start" ? input?.source : input?.reason;
+    return JSON.stringify({
+      sessionId,
+      event,
+      ...(typeof reason === "string" && reason !== "" && { reason }),
+      at,
+    });
+  } catch {
+    return null;
+  }
+}
+
+function main() {
+  try {
+    const line = journalLineOf(readFileSync(0, "utf8"), new Date().toISOString());
+    if (line === null) return;
+    // The path is the user's homedir plus fixed segments — nothing from the
+    // hook input can steer where the journal lands.
+    const file = journalPath(os.homedir());
+    // eslint-disable-next-line security/detect-non-literal-fs-filename
+    mkdirSync(path.dirname(file), { recursive: true });
+    // eslint-disable-next-line security/detect-non-literal-fs-filename
+    appendFileSync(file, `${line}\n`);
+  } catch {
+    // never surface an error into someone's session
+  }
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  main();
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@usepowerplant/cli",
+  "version": "0.3.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "Powerplant machine setup: enroll this machine, run the session collector in the background, and manage it.",
+  "license": "UNLICENSED",
+  "homepage": "https://powerplant.sh",
+  "bugs": {
+    "email": "support@forestwalk.ai"
+  },
+  "type": "module",
+  "bin": {
+    "powerplant": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "node build.mjs",
+    "type-check": "tsc --noEmit",
+    "test": "vitest run"
+  },
+  "devDependencies": {
+    "@powerplant/collector": "workspace:*",
+    "@powerplant/core": "workspace:*",
+    "@types/node": "^26.3.0",
+    "esbuild": "^0.28.2",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.11",
+    "zod": "^4.4.3"
+  }
+}