@a5c-ai/babysitter-opencode 0.1.1-staging.0dc03363

package/hooks/hooks.json

@@ -0,0 +1,46 @@
+{
+  "version": 1,
+  "description": "Babysitter hook registration for OpenCode. Maps OpenCode plugin events to babysitter hook scripts.",
+  "hooks": {
+    "session.created": [
+      {
+        "type": "command",
+        "script": "hooks/session-created.js",
+        "description": "Initialize babysitter session state and inject context",
+        "timeoutMs": 30000
+      }
+    ],
+    "session.idle": [
+      {
+        "type": "command",
+        "script": "hooks/session-idle.js",
+        "description": "Check for pending babysitter effects when agent goes idle",
+        "timeoutMs": 30000
+      }
+    ],
+    "shell.env": [
+      {
+        "type": "command",
+        "script": "hooks/shell-env.js",
+        "description": "Inject BABYSITTER_SESSION_ID and other env vars into shell",
+        "timeoutMs": 5000
+      }
+    ],
+    "tool.execute.before": [
+      {
+        "type": "command",
+        "script": "hooks/tool-execute-before.js",
+        "description": "Pre-tool-use hook for babysitter awareness",
+        "timeoutMs": 10000
+      }
+    ],
+    "tool.execute.after": [
+      {
+        "type": "command",
+        "script": "hooks/tool-execute-after.js",
+        "description": "Post-tool-use hook for babysitter awareness",
+        "timeoutMs": 10000
+      }
+    ]
+  }
+}

package/hooks/session-created.js

@@ -0,0 +1,180 @@
+#!/usr/bin/env node
+/**
+ * Babysitter Session Created Hook for OpenCode
+ *
+ * Fires when an OpenCode session is created. Ensures the babysitter SDK CLI
+ * is installed, then delegates to `babysitter hook:run --hook-type session-start`
+ * to create baseline session state.
+ *
+ * OpenCode plugin protocol:
+ *   - Receives event context as JSON via process.argv or stdin
+ *   - Outputs JSON to stdout
+ *   - Exit 0 = success
+ */
+
+"use strict";
+
+const { execSync, execFileSync } = require("child_process");
+const { readFileSync, mkdirSync, appendFileSync, existsSync, writeFileSync } = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+
+const PLUGIN_ROOT = process.env.OPENCODE_PLUGIN_ROOT || path.resolve(__dirname, "..");
+const STATE_DIR = process.env.BABYSITTER_STATE_DIR || path.join(process.cwd(), ".a5c");
+const LOG_DIR = process.env.BABYSITTER_LOG_DIR || path.join(PLUGIN_ROOT, ".a5c", "logs");
+const LOG_FILE = path.join(LOG_DIR, "babysitter-session-created-hook.log");
+
+// ---------------------------------------------------------------------------
+// Logging
+// ---------------------------------------------------------------------------
+
+function ensureDir(dir) {
+  try { mkdirSync(dir, { recursive: true }); } catch { /* best-effort */ }
+}
+
+function blog(msg) {
+  ensureDir(LOG_DIR);
+  const ts = new Date().toISOString();
+  try {
+    appendFileSync(LOG_FILE, `[INFO] ${ts} ${msg}\n`);
+  } catch { /* best-effort */ }
+}
+
+// ---------------------------------------------------------------------------
+// SDK version & install
+// ---------------------------------------------------------------------------
+
+function getSdkVersion() {
+  try {
+    const versions = JSON.parse(readFileSync(path.join(PLUGIN_ROOT, "versions.json"), "utf8"));
+    return versions.sdkVersion || "latest";
+  } catch {
+    return "latest";
+  }
+}
+
+function hasBabysitterCli() {
+  try {
+    execSync("babysitter --version", { stdio: "pipe", timeout: 10000 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function installSdk(version) {
+  const marker = path.join(PLUGIN_ROOT, ".babysitter-install-attempted");
+  if (existsSync(marker)) return;
+
+  try {
+    execSync(`npm i -g "@a5c-ai/babysitter-sdk@${version}" --loglevel=error`, {
+      stdio: "pipe",
+      timeout: 120000,
+    });
+    blog(`Installed SDK globally (${version})`);
+  } catch {
+    // Try user-local prefix
+    try {
+      const prefix = path.join(process.env.HOME || process.env.USERPROFILE || "~", ".local");
+      execSync(`npm i -g "@a5c-ai/babysitter-sdk@${version}" --prefix "${prefix}" --loglevel=error`, {
+        stdio: "pipe",
+        timeout: 120000,
+      });
+      blog(`Installed SDK to user prefix (${version})`);
+    } catch {
+      blog("SDK installation failed");
+    }
+  }
+
+  try { writeFileSync(marker, version); } catch { /* best-effort */ }
+}
+
+// ---------------------------------------------------------------------------
+// CLI execution helper
+// ---------------------------------------------------------------------------
+
+function runBabysitterHook(hookType, inputJson) {
+  const sdkVersion = getSdkVersion();
+  const args = [
+    "hook:run",
+    "--hook-type", hookType,
+    "--harness", "opencode",
+    "--plugin-root", PLUGIN_ROOT,
+    "--state-dir", STATE_DIR,
+    "--json",
+  ];
+
+  try {
+    const result = execSync(`babysitter ${args.join(" ")}`, {
+      input: inputJson,
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 30000,
+      env: { ...process.env, BABYSITTER_STATE_DIR: STATE_DIR },
+    });
+    return result.toString("utf8").trim();
+  } catch (err) {
+    // Fall back to npx
+    try {
+      const result = execSync(`npx -y "@a5c-ai/babysitter-sdk@${sdkVersion}" ${args.join(" ")}`, {
+        input: inputJson,
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: 60000,
+        env: { ...process.env, BABYSITTER_STATE_DIR: STATE_DIR },
+      });
+      return result.toString("utf8").trim();
+    } catch (npxErr) {
+      blog(`Hook execution failed: ${npxErr.message}`);
+      return "{}";
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+function main() {
+  blog("session-created hook invoked");
+  blog(`PLUGIN_ROOT=${PLUGIN_ROOT}`);
+
+  // Generate a session ID if OpenCode doesn't provide one
+  const sessionId = process.env.OPENCODE_SESSION_ID
+    || process.env.BABYSITTER_SESSION_ID
+    || crypto.randomUUID();
+
+  // Set env var so downstream hooks can pick it up
+  process.env.BABYSITTER_SESSION_ID = sessionId;
+
+  const sdkVersion = getSdkVersion();
+
+  // Ensure SDK is installed
+  if (!hasBabysitterCli()) {
+    blog("SDK CLI not found, attempting install");
+    installSdk(sdkVersion);
+  }
+
+  // Build hook input
+  const hookInput = JSON.stringify({
+    session_id: sessionId,
+    cwd: process.cwd(),
+    harness: "opencode",
+    plugin_root: PLUGIN_ROOT,
+  });
+
+  blog(`Hook input: ${hookInput}`);
+
+  // Delegate to SDK hook handler
+  const result = runBabysitterHook("session-start", hookInput);
+
+  blog(`Hook result: ${result}`);
+
+  // Output result
+  try {
+    const parsed = JSON.parse(result);
+    process.stdout.write(JSON.stringify(parsed) + "\n");
+  } catch {
+    process.stdout.write("{}\n");
+  }
+}
+
+main();

package/hooks/session-idle.js

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+/**
+ * Babysitter Session Idle Hook for OpenCode
+ *
+ * Fires when the OpenCode agent goes idle. Checks if the current babysitter
+ * run has pending effects that need attention. Since OpenCode does NOT have a
+ * blocking stop hook, this is fire-and-forget -- it outputs context about
+ * pending effects so the agent can decide whether to continue iterating.
+ *
+ * Delegates to `babysitter hook:run --hook-type stop` (which handles the
+ * run-state inspection and iteration tracking).
+ *
+ * OpenCode plugin protocol:
+ *   - Receives event context as JSON via stdin
+ *   - Outputs JSON to stdout
+ *   - Exit 0 = success
+ */
+
+"use strict";
+
+const { execSync } = require("child_process");
+const { readFileSync, mkdirSync, appendFileSync } = require("fs");
+const path = require("path");
+
+const PLUGIN_ROOT = process.env.OPENCODE_PLUGIN_ROOT || path.resolve(__dirname, "..");
+const STATE_DIR = process.env.BABYSITTER_STATE_DIR || path.join(process.cwd(), ".a5c");
+const LOG_DIR = process.env.BABYSITTER_LOG_DIR || path.join(PLUGIN_ROOT, ".a5c", "logs");
+const LOG_FILE = path.join(LOG_DIR, "babysitter-session-idle-hook.log");
+
+function ensureDir(dir) {
+  try { mkdirSync(dir, { recursive: true }); } catch { /* best-effort */ }
+}
+
+function blog(msg) {
+  ensureDir(LOG_DIR);
+  const ts = new Date().toISOString();
+  try {
+    appendFileSync(LOG_FILE, `[INFO] ${ts} ${msg}\n`);
+  } catch { /* best-effort */ }
+}
+
+function getSdkVersion() {
+  try {
+    const versions = JSON.parse(readFileSync(path.join(PLUGIN_ROOT, "versions.json"), "utf8"));
+    return versions.sdkVersion || "latest";
+  } catch {
+    return "latest";
+  }
+}
+
+function runBabysitterHook(hookType, inputJson) {
+  const sdkVersion = getSdkVersion();
+  const args = [
+    "hook:run",
+    "--hook-type", hookType,
+    "--harness", "opencode",
+    "--plugin-root", PLUGIN_ROOT,
+    "--state-dir", STATE_DIR,
+    "--json",
+  ];
+
+  try {
+    const result = execSync(`babysitter ${args.join(" ")}`, {
+      input: inputJson,
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 30000,
+      env: { ...process.env, BABYSITTER_STATE_DIR: STATE_DIR },
+    });
+    return result.toString("utf8").trim();
+  } catch {
+    try {
+      const result = execSync(`npx -y "@a5c-ai/babysitter-sdk@${sdkVersion}" ${args.join(" ")}`, {
+        input: inputJson,
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: 60000,
+        env: { ...process.env, BABYSITTER_STATE_DIR: STATE_DIR },
+      });
+      return result.toString("utf8").trim();
+    } catch (err) {
+      blog(`Hook execution failed: ${err.message}`);
+      return "{}";
+    }
+  }
+}
+
+function main() {
+  blog("session-idle hook invoked");
+
+  const sessionId = process.env.BABYSITTER_SESSION_ID
+    || process.env.OPENCODE_SESSION_ID
+    || "";
+
+  if (!sessionId) {
+    blog("No session ID -- nothing to check");
+    process.stdout.write("{}\n");
+    return;
+  }
+
+  const hookInput = JSON.stringify({
+    session_id: sessionId,
+    cwd: process.cwd(),
+    harness: "opencode",
+    plugin_root: PLUGIN_ROOT,
+  });
+
+  blog(`Checking run status for session ${sessionId}`);
+
+  // Delegate to the stop hook handler, which inspects run state
+  // and returns block/allow decisions
+  const result = runBabysitterHook("stop", hookInput);
+
+  blog(`Hook result: ${result}`);
+
+  try {
+    const parsed = JSON.parse(result);
+    process.stdout.write(JSON.stringify(parsed) + "\n");
+  } catch {
+    process.stdout.write("{}\n");
+  }
+}
+
+main();

package/hooks/shell-env.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+/**
+ * Babysitter Shell Environment Hook for OpenCode
+ *
+ * Fires when OpenCode initializes a shell environment. Injects babysitter
+ * environment variables (BABYSITTER_SESSION_ID, BABYSITTER_STATE_DIR, etc.)
+ * so that subprocesses and other hooks can discover the active session.
+ *
+ * This is critical for OpenCode because it does NOT natively inject
+ * distinctive env vars into plugins -- the babysitter plugin must self-inject
+ * them via this hook.
+ *
+ * OpenCode plugin protocol:
+ *   - Outputs env var assignments as JSON: { "env": { "KEY": "VALUE" } }
+ *   - Exit 0 = success
+ */
+
+"use strict";
+
+const { readFileSync, mkdirSync, appendFileSync, existsSync } = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+
+const PLUGIN_ROOT = process.env.OPENCODE_PLUGIN_ROOT || path.resolve(__dirname, "..");
+const STATE_DIR = process.env.BABYSITTER_STATE_DIR || path.join(process.cwd(), ".a5c");
+const RUNS_DIR = process.env.BABYSITTER_RUNS_DIR || path.join(STATE_DIR, "runs");
+const LOG_DIR = process.env.BABYSITTER_LOG_DIR || path.join(PLUGIN_ROOT, ".a5c", "logs");
+const LOG_FILE = path.join(LOG_DIR, "babysitter-shell-env-hook.log");
+
+function ensureDir(dir) {
+  try { mkdirSync(dir, { recursive: true }); } catch { /* best-effort */ }
+}
+
+function blog(msg) {
+  ensureDir(LOG_DIR);
+  const ts = new Date().toISOString();
+  try {
+    appendFileSync(LOG_FILE, `[INFO] ${ts} ${msg}\n`);
+  } catch { /* best-effort */ }
+}
+
+function getSdkVersion() {
+  try {
+    const versions = JSON.parse(readFileSync(path.join(PLUGIN_ROOT, "versions.json"), "utf8"));
+    return versions.sdkVersion || "latest";
+  } catch {
+    return "latest";
+  }
+}
+
+function main() {
+  blog("shell-env hook invoked");
+
+  // Resolve or generate session ID
+  const sessionId = process.env.BABYSITTER_SESSION_ID
+    || process.env.OPENCODE_SESSION_ID
+    || crypto.randomUUID();
+
+  const sdkVersion = getSdkVersion();
+
+  // Build env vars to inject
+  const env = {
+    BABYSITTER_SESSION_ID: sessionId,
+    OPENCODE_SESSION_ID: sessionId,
+    BABYSITTER_STATE_DIR: STATE_DIR,
+    BABYSITTER_RUNS_DIR: RUNS_DIR,
+    OPENCODE_PLUGIN_ROOT: PLUGIN_ROOT,
+  };
+
+  // Add SDK version for downstream hooks
+  if (sdkVersion && sdkVersion !== "latest") {
+    env.BABYSITTER_SDK_VERSION = sdkVersion;
+  }
+
+  // Add global state dir if defined
+  const globalStateDir = process.env.BABYSITTER_GLOBAL_STATE_DIR;
+  if (globalStateDir) {
+    env.BABYSITTER_GLOBAL_STATE_DIR = globalStateDir;
+  }
+
+  blog(`Injecting env: ${JSON.stringify(env)}`);
+
+  process.stdout.write(JSON.stringify({ env }) + "\n");
+}
+
+main();

package/hooks/tool-execute-after.js

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+/**
+ * Babysitter Tool Execute After Hook for OpenCode
+ *
+ * Fires after a tool execution in OpenCode. Delegates to
+ * `babysitter hook:run --hook-type post-tool-use` for post-tool-use awareness.
+ *
+ * This hook can be used to:
+ * - Log tool execution results for babysitter run observability
+ * - Trigger babysitter effects based on tool outputs
+ * - Update session state after tool executions
+ *
+ * OpenCode plugin protocol:
+ *   - Receives tool result context as JSON via stdin
+ *   - Outputs JSON to stdout
+ *   - Exit 0 = success
+ */
+
+"use strict";
+
+const { execSync } = require("child_process");
+const { readFileSync, mkdirSync, appendFileSync } = require("fs");
+const path = require("path");
+
+const PLUGIN_ROOT = process.env.OPENCODE_PLUGIN_ROOT || path.resolve(__dirname, "..");
+const STATE_DIR = process.env.BABYSITTER_STATE_DIR || path.join(process.cwd(), ".a5c");
+const LOG_DIR = process.env.BABYSITTER_LOG_DIR || path.join(PLUGIN_ROOT, ".a5c", "logs");
+const LOG_FILE = path.join(LOG_DIR, "babysitter-tool-after-hook.log");
+
+function ensureDir(dir) {
+  try { mkdirSync(dir, { recursive: true }); } catch { /* best-effort */ }
+}
+
+function blog(msg) {
+  ensureDir(LOG_DIR);
+  const ts = new Date().toISOString();
+  try {
+    appendFileSync(LOG_FILE, `[INFO] ${ts} ${msg}\n`);
+  } catch { /* best-effort */ }
+}
+
+function getSdkVersion() {
+  try {
+    const versions = JSON.parse(readFileSync(path.join(PLUGIN_ROOT, "versions.json"), "utf8"));
+    return versions.sdkVersion || "latest";
+  } catch {
+    return "latest";
+  }
+}
+
+function main() {
+  const sessionId = process.env.BABYSITTER_SESSION_ID
+    || process.env.OPENCODE_SESSION_ID
+    || "";
+
+  if (!sessionId) {
+    process.stdout.write("{}\n");
+    return;
+  }
+
+  // Read stdin for tool result context
+  let inputData = "";
+  try {
+    inputData = require("fs").readFileSync(0, "utf8");
+  } catch {
+    // No stdin available
+  }
+
+  blog(`tool-execute-after: session=${sessionId}`);
+
+  const hookInput = JSON.stringify({
+    session_id: sessionId,
+    cwd: process.cwd(),
+    harness: "opencode",
+    plugin_root: PLUGIN_ROOT,
+    tool_result: inputData ? JSON.parse(inputData) : {},
+  });
+
+  const sdkVersion = getSdkVersion();
+  const args = [
+    "hook:run",
+    "--hook-type", "post-tool-use",
+    "--harness", "opencode",
+    "--plugin-root", PLUGIN_ROOT,
+    "--state-dir", STATE_DIR,
+    "--json",
+  ];
+
+  try {
+    const result = execSync(`babysitter ${args.join(" ")}`, {
+      input: hookInput,
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 10000,
+      env: { ...process.env, BABYSITTER_STATE_DIR: STATE_DIR },
+    });
+    const output = result.toString("utf8").trim();
+    blog(`Hook result: ${output}`);
+    process.stdout.write((output || "{}") + "\n");
+  } catch {
+    blog("Post-tool-use hook failed -- non-blocking");
+    process.stdout.write("{}\n");
+  }
+}
+
+main();

package/hooks/tool-execute-before.js

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+/**
+ * Babysitter Tool Execute Before Hook for OpenCode
+ *
+ * Fires before a tool execution in OpenCode. Delegates to
+ * `babysitter hook:run --hook-type pre-tool-use` for pre-tool-use awareness.
+ *
+ * This hook can be used to:
+ * - Log tool invocations for babysitter run observability
+ * - Block certain tool calls during specific orchestration phases
+ * - Inject babysitter context into tool arguments
+ *
+ * OpenCode plugin protocol:
+ *   - Receives tool context as JSON via stdin
+ *   - Outputs JSON to stdout (empty = allow, { block: true } = block)
+ *   - Exit 0 = success
+ */
+
+"use strict";
+
+const { execSync } = require("child_process");
+const { readFileSync, mkdirSync, appendFileSync } = require("fs");
+const path = require("path");
+
+const PLUGIN_ROOT = process.env.OPENCODE_PLUGIN_ROOT || path.resolve(__dirname, "..");
+const STATE_DIR = process.env.BABYSITTER_STATE_DIR || path.join(process.cwd(), ".a5c");
+const LOG_DIR = process.env.BABYSITTER_LOG_DIR || path.join(PLUGIN_ROOT, ".a5c", "logs");
+const LOG_FILE = path.join(LOG_DIR, "babysitter-tool-before-hook.log");
+
+function ensureDir(dir) {
+  try { mkdirSync(dir, { recursive: true }); } catch { /* best-effort */ }
+}
+
+function blog(msg) {
+  ensureDir(LOG_DIR);
+  const ts = new Date().toISOString();
+  try {
+    appendFileSync(LOG_FILE, `[INFO] ${ts} ${msg}\n`);
+  } catch { /* best-effort */ }
+}
+
+function getSdkVersion() {
+  try {
+    const versions = JSON.parse(readFileSync(path.join(PLUGIN_ROOT, "versions.json"), "utf8"));
+    return versions.sdkVersion || "latest";
+  } catch {
+    return "latest";
+  }
+}
+
+function main() {
+  const sessionId = process.env.BABYSITTER_SESSION_ID
+    || process.env.OPENCODE_SESSION_ID
+    || "";
+
+  if (!sessionId) {
+    // No session -- pass through without intervention
+    process.stdout.write("{}\n");
+    return;
+  }
+
+  // Read stdin for tool context
+  let inputData = "";
+  try {
+    inputData = require("fs").readFileSync(0, "utf8");
+  } catch {
+    // No stdin available
+  }
+
+  blog(`tool-execute-before: session=${sessionId}`);
+
+  const hookInput = JSON.stringify({
+    session_id: sessionId,
+    cwd: process.cwd(),
+    harness: "opencode",
+    plugin_root: PLUGIN_ROOT,
+    tool_context: inputData ? JSON.parse(inputData) : {},
+  });
+
+  const sdkVersion = getSdkVersion();
+  const args = [
+    "hook:run",
+    "--hook-type", "pre-tool-use",
+    "--harness", "opencode",
+    "--plugin-root", PLUGIN_ROOT,
+    "--state-dir", STATE_DIR,
+    "--json",
+  ];
+
+  try {
+    const result = execSync(`babysitter ${args.join(" ")}`, {
+      input: hookInput,
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 10000,
+      env: { ...process.env, BABYSITTER_STATE_DIR: STATE_DIR },
+    });
+    const output = result.toString("utf8").trim();
+    blog(`Hook result: ${output}`);
+    process.stdout.write((output || "{}") + "\n");
+  } catch {
+    // On failure, allow the tool execution to proceed
+    blog("Pre-tool-use hook failed -- allowing execution");
+    process.stdout.write("{}\n");
+  }
+}
+
+main();

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@a5c-ai/babysitter-opencode",
+  "version": "0.1.1-staging.0dc03363",
+  "description": "Babysitter orchestration plugin for OpenCode with SDK-managed process-library bootstrapping and in-turn iteration model",
+  "scripts": {
+    "test": "node test/integration.test.js",
+    "test:integration": "node test/integration.test.js",
+    "sync:commands": "node scripts/sync-command-docs.cjs",
+    "postinstall": "node bin/install.cjs",
+    "preuninstall": "node bin/uninstall.cjs",
+    "deploy": "npm publish --access public",
+    "deploy:staging": "npm publish --access public --tag staging"
+  },
+  "bin": {
+    "babysitter-opencode": "bin/cli.cjs"
+  },
+  "files": [
+    "bin/",
+    "commands/",
+    "hooks/",
+    "scripts/",
+    "skills/",
+    "plugin.json",
+    "versions.json"
+  ],
+  "keywords": [
+    "babysitter",
+    "opencode",
+    "orchestration",
+    "ai-agent",
+    "sdk-integration"
+  ],
+  "author": "a5c.ai",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/a5c-ai/babysitter"
+  },
+  "homepage": "https://github.com/a5c-ai/babysitter/tree/main/plugins/babysitter-opencode#readme",
+  "dependencies": {
+    "@a5c-ai/babysitter-sdk": "0.0.184-staging.0dc03363"
+  }
+}