lilflow 0.1.1 → 0.2.1

package/src/session-runner.js

@@ -0,0 +1,152 @@
+import { spawn } from "node:child_process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { resolveAgentBinary } from "./agents/index.js";
+import { buildSessionSystemPrompt } from "./session-prompt.js";
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+
+/**
+ * Path to the bundled plugin that exposes the lilflow skill. The plugin lives
+ * at the repo/package root — `.claude-plugin/plugin.json` is the marker file,
+ * sibling `skills/`, `commands/`, etc. are auto-discovered. Works for both
+ * providers: Claude Code loads it natively, and OpenCode picks it up through
+ * oh-my-opencode's Claude Code compatibility layer.
+ *
+ * @returns {string} Absolute directory path (repo/package root).
+ */
+export function getBundledPluginPath() {
+  return path.resolve(HERE, "..");
+}
+
+/**
+ * Execute a workflow in session mode. Spawns one long-lived agent process,
+ * injects the workflow-aware system prompt, and lets the agent drive the bridge.
+ *
+ * @param {object} options - Runtime options.
+ * @param {object} options.workflow - Loaded workflow with `mode: "session"`.
+ * @param {string} options.workflowPath - Absolute workflow path.
+ * @param {string} options.cwd - Working directory.
+ * @param {object} options.env - Process environment.
+ * @param {(message: string) => void} options.stdout - Output writer.
+ * @param {(message: string) => void} options.stderr - Error writer.
+ * @param {object} options.flowConfig - Resolved flow config.
+ * @param {{runId: string}} options.eventLogger - Already-initialized logger.
+ * @param {typeof spawn} [options.spawnProcess=spawn] - Injection for tests.
+ * @returns {Promise<{exitCode: number, runId: string}>} Session result.
+ */
+export async function executeSessionWorkflow(options) {
+  const {
+    workflow,
+    workflowPath,
+    cwd,
+    env,
+    stdout,
+    stderr,
+    flowConfig,
+    eventLogger,
+    spawnProcess = spawn
+  } = options;
+
+  if (workflow.mode !== "session") {
+    throw new Error("executeSessionWorkflow requires workflow.mode === 'session'.");
+  }
+
+  if (!workflow.session || (workflow.session.provider !== "claude-code" && workflow.session.provider !== "opencode")) {
+    throw new Error("Session mode supports provider 'claude-code' or 'opencode'.");
+  }
+
+  const runId = eventLogger.runId;
+  const systemPrompt = buildSessionSystemPrompt(workflow, runId);
+  const pluginPath = getBundledPluginPath();
+
+  const childEnv = {
+    ...env,
+    FLOW_RUN_ID: runId,
+    FLOW_WORKFLOW_PATH: workflowPath,
+    // Both providers recognize CLAUDE_PLUGINS_PATH when oh-my-opencode loads
+    // Claude Code plugins.
+    CLAUDE_PLUGINS_PATH: [pluginPath, env.CLAUDE_PLUGINS_PATH].filter(Boolean).join(path.delimiter)
+  };
+
+  const provider = workflow.session.provider;
+  const { binary, args, interactive } = provider === "claude-code"
+    ? await buildClaudeArgs(workflow, systemPrompt, flowConfig, env)
+    : await buildOpencodeArgs(workflow, systemPrompt, flowConfig, env);
+
+  stdout(`Starting session-mode workflow '${workflow.name}' (run ${runId}, provider ${provider}).`);
+
+  if (provider === "opencode" && interactive) {
+    // OpenCode does not expose a --append-system-prompt flag, so we surface the
+    // system prompt to the user before the TUI takes over. The user pastes it
+    // (or the skill picks it up from FLOW_RUN_ID and re-fetches workflow state).
+    stdout("");
+    stdout("=== Workflow system prompt (paste into opencode if not auto-loaded) ===");
+    stdout(systemPrompt);
+    stdout("=== End system prompt ===");
+    stdout("");
+  }
+
+  return new Promise((resolve, reject) => {
+    const child = spawnProcess(binary, args, {
+      cwd,
+      env: childEnv,
+      stdio: "inherit"
+    });
+
+    child.on("error", (error) => {
+      reject(new Error(`Failed to start ${provider} agent: ${error.message}`));
+    });
+
+    child.on("close", (code, signal) => {
+      if (signal) {
+        stderr(`${provider} agent exited due to signal ${signal}`);
+      }
+      resolve({ exitCode: code ?? 1, runId });
+    });
+  });
+}
+
+/**
+ * Build claude CLI invocation arguments.
+ */
+async function buildClaudeArgs(workflow, systemPrompt, flowConfig, env) {
+  const binary = await resolveAgentBinary("claude-code", flowConfig, env);
+  const args = [];
+
+  if (workflow.session.model) {
+    args.push("--model", workflow.session.model);
+  }
+
+  if (Array.isArray(workflow.session.allowTools) && workflow.session.allowTools.length > 0) {
+    args.push("--allowedTools", ...workflow.session.allowTools);
+  }
+
+  args.push("--append-system-prompt", systemPrompt);
+  args.push("--dangerously-skip-permissions");
+
+  return { binary, args, interactive: true };
+}
+
+/**
+ * Build opencode CLI invocation arguments. Opencode has no
+ * `--append-system-prompt` equivalent — the system prompt is surfaced to the
+ * user above the TUI and the skill (loaded via oh-my-opencode's Claude Code
+ * compatibility layer) picks up the rest from FLOW_RUN_ID.
+ */
+async function buildOpencodeArgs(workflow, _systemPrompt, flowConfig, env) {
+  const binary = await resolveAgentBinary("opencode", flowConfig, env);
+  const args = [];
+
+  if (workflow.session.model) {
+    args.push("--model", workflow.session.model);
+  }
+
+  if (Array.isArray(workflow.session.plugins)) {
+    for (const plugin of workflow.session.plugins) {
+      args.push("--plugin", plugin);
+    }
+  }
+
+  return { binary, args, interactive: true };
+}