@scrylog/cli 0.1.0

package/src/mcp/services/api-adapter.ts

@@ -0,0 +1,48 @@
+import { flattenSessionTree } from "../../shared/session-view";
+import type { SessionTreeItem, SessionListItem } from "../../shared/session-view";
+import type { DataSource } from "./data-source";
+
+type FetchFn = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+
+export function createApiAdapter(daemonFetch: FetchFn): DataSource {
+  return {
+    fetchSessions: async () => {
+      const response = await daemonFetch("/api/sessions");
+      const data = (await response.json()) as { sessions: SessionTreeItem[] };
+      return data.sessions;
+    },
+
+    fetchSession: async (id) => {
+      const response = await daemonFetch(`/api/sessions/${encodeURIComponent(id)}`);
+      if (response.status === 404) return null;
+      const data = (await response.json()) as { session: unknown };
+      return data.session as any;
+    },
+
+    fetchSessionChildren: async (id) => {
+      const response = await daemonFetch(`/api/sessions/${encodeURIComponent(id)}/children`);
+      if (response.status === 404) return [];
+      const data = (await response.json()) as { children: SessionListItem[] };
+      return data.children;
+    },
+
+    fetchSessionMessages: async (id) => {
+      const response = await daemonFetch(`/api/sessions/${encodeURIComponent(id)}/messages`);
+      if (response.status === 404) return { sessionId: id, messages: [] };
+      return await response.json();
+    },
+
+    fetchActiveSessions: async () => {
+      const response = await daemonFetch("/api/sessions");
+      const data = (await response.json()) as { sessions: SessionTreeItem[] };
+      return flattenSessionTree(data.sessions).filter(
+        (s) => s.state === "working" || s.state === "waiting-input",
+      );
+    },
+
+    fetchConfig: async () => {
+      const response = await daemonFetch("/api/config");
+      return await response.json();
+    },
+  };
+}

package/src/mcp/services/data-source.ts

@@ -0,0 +1,22 @@
+import type { SessionTreeItem, SessionListItem } from "../../shared/session-view";
+import type { SessionModel } from "../../shared/types";
+
+/**
+ * Uniform data-access interface for MCP tools and resources.
+ * Both the in-daemon server and the stdio binary implement this
+ * via StoreAdapter and ApiAdapter respectively.
+ */
+export interface DataSource {
+  /** Fetch the full visible session tree (roots with children arrays). */
+  fetchSessions(): Promise<SessionTreeItem[]>;
+  /** Fetch a single session by ID, or null if not found. */
+  fetchSession(id: string): Promise<SessionModel | null>;
+  /** Fetch active children of a parent session. */
+  fetchSessionChildren(id: string): Promise<SessionListItem[]>;
+  /** Fetch recent messages for a session (returns messages payload or empty object). */
+  fetchSessionMessages(id: string): Promise<unknown>;
+  /** Fetch all active (working / waiting-input) sessions flattened. */
+  fetchActiveSessions(): Promise<SessionListItem[]>;
+  /** Fetch current daemon configuration (sensitive fields redacted). */
+  fetchConfig(): Promise<unknown>;
+}

package/src/mcp/services/store-adapter.ts

@@ -0,0 +1,40 @@
+import type { DaemonStore } from "../../daemon/store";
+import type { ScrylogConfig } from "../../shared/config";
+import { buildSessionView, flattenSessionTree } from "../../shared/session-view";
+import type { DataSource } from "./data-source";
+
+export function createStoreAdapter(store: DaemonStore, config: ScrylogConfig): DataSource {
+  function getSessionView() {
+    return buildSessionView(store.getSessions(), config);
+  }
+
+  return {
+    fetchSessions: async () => getSessionView().sessions,
+
+    fetchSession: async (id) => store.getSession(id) ?? null,
+
+    fetchSessionChildren: async (id) => {
+      const parent = store.getSession(id);
+      if (!parent) return [];
+      return getSessionView().sessions.find((s) => s.id === id)?.children ?? [];
+    },
+
+    fetchSessionMessages: async (id) => {
+      const session = store.getSession(id);
+      if (!session) return { sessionId: id, messages: [] };
+      return { sessionId: id, messages: [] };
+    },
+
+    fetchActiveSessions: async () => {
+      return flattenSessionTree(getSessionView().sessions).filter(
+        (s) => s.state === "working" || s.state === "waiting-input",
+      );
+    },
+
+    fetchConfig: async () => ({
+      ...config,
+      api: { ...config.api, bearerToken: undefined },
+      mcp: { ...config.mcp, bearerToken: undefined },
+    }),
+  };
+}

package/src/mcp/tools/get-active-sessions.ts

@@ -0,0 +1,16 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { DataSource } from "../services/data-source";
+
+export function registerGetActiveSessions(server: McpServer, ds: DataSource) {
+  server.tool(
+    "get_active_sessions",
+    "List sessions that are currently in a working or waiting-input state",
+    {},
+    async () => {
+      const sessions = await ds.fetchActiveSessions();
+      return {
+        content: [{ type: "text" as const, text: JSON.stringify(sessions, null, 2) }],
+      };
+    },
+  );
+}

package/src/mcp/tools/get-session-children.ts

@@ -0,0 +1,24 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { SessionIdSchema } from "../schemas/sessions";
+import type { DataSource } from "../services/data-source";
+
+export function registerGetSessionChildren(server: McpServer, ds: DataSource) {
+  server.tool(
+    "get_session_children",
+    "Get all active sub-agent sessions spawned by a parent session, with full detail",
+    { id: SessionIdSchema },
+    async ({ id }) => {
+      const session = await ds.fetchSession(id);
+      if (!session) {
+        return {
+          isError: true,
+          content: [{ type: "text" as const, text: `Session '${id}' not found` }],
+        };
+      }
+      const children = await ds.fetchSessionChildren(id);
+      return {
+        content: [{ type: "text" as const, text: JSON.stringify({ sessionId: id, children }, null, 2) }],
+      };
+    },
+  );
+}

package/src/mcp/tools/get-session-messages.ts

@@ -0,0 +1,24 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { SessionIdSchema } from "../schemas/sessions";
+import type { DataSource } from "../services/data-source";
+
+export function registerGetSessionMessages(server: McpServer, ds: DataSource) {
+  server.tool(
+    "get_session_messages",
+    "Get recent messages for a session (if available from Claude transcript or OpenCode SDK)",
+    { id: SessionIdSchema },
+    async ({ id }) => {
+      const session = await ds.fetchSession(id);
+      if (!session) {
+        return {
+          isError: true,
+          content: [{ type: "text" as const, text: `Session '${id}' not found` }],
+        };
+      }
+      const messages = await ds.fetchSessionMessages(id);
+      return {
+        content: [{ type: "text" as const, text: JSON.stringify(messages, null, 2) }],
+      };
+    },
+  );
+}

package/src/mcp/tools/get-session.ts

@@ -0,0 +1,23 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { SessionIdSchema } from "../schemas/sessions";
+import type { DataSource } from "../services/data-source";
+
+export function registerGetSession(server: McpServer, ds: DataSource) {
+  server.tool(
+    "get_session",
+    "Get details for a specific session by ID",
+    { id: SessionIdSchema },
+    async ({ id }) => {
+      const session = await ds.fetchSession(id);
+      if (!session) {
+        return {
+          isError: true,
+          content: [{ type: "text" as const, text: `Session '${id}' not found` }],
+        };
+      }
+      return {
+        content: [{ type: "text" as const, text: JSON.stringify(session, null, 2) }],
+      };
+    },
+  );
+}

package/src/mcp/tools/index.ts

@@ -0,0 +1,15 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { DataSource } from "../services/data-source";
+import { registerListSessions } from "./list-sessions";
+import { registerGetActiveSessions } from "./get-active-sessions";
+import { registerGetSession } from "./get-session";
+import { registerGetSessionMessages } from "./get-session-messages";
+import { registerGetSessionChildren } from "./get-session-children";
+
+export function registerAllTools(server: McpServer, ds: DataSource) {
+  registerListSessions(server, ds);
+  registerGetActiveSessions(server, ds);
+  registerGetSession(server, ds);
+  registerGetSessionMessages(server, ds);
+  registerGetSessionChildren(server, ds);
+}

package/src/mcp/tools/list-sessions.ts

@@ -0,0 +1,16 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { DataSource } from "../services/data-source";
+
+export function registerListSessions(server: McpServer, ds: DataSource) {
+  server.tool(
+    "list_sessions",
+    "List all monitored AI coding sessions as a tree. Root sessions include a 'children' array of active sub-agent sessions.",
+    {},
+    async () => {
+      const sessions = await ds.fetchSessions();
+      return {
+        content: [{ type: "text" as const, text: JSON.stringify(sessions, null, 2) }],
+      };
+    },
+  );
+}

package/src/neo-blessed.d.ts

@@ -0,0 +1,4 @@
+declare module "neo-blessed" {
+  import blessed = require("blessed");
+  export = blessed;
+}

package/src/oc/index.ts

@@ -0,0 +1,302 @@
+#!/usr/bin/env bun
+/**
+ * oc — OpenCode launcher / attach helper
+ *
+ * Usage:
+ *   oc [args...]          Auto-discover running instance → attach or launch
+ *   oc [args...]          All extra args are forwarded to the opencode command
+ *
+ * Environment variables:
+ *   OPENCODE_LOCAL_PORT   Force a specific port   (skips discovery)
+ *   OPENCODE_HOST         Force a specific host   (skips discovery, default 127.0.0.1)
+ *
+ * When both env vars are absent, oc discovers running opencode processes via
+ * process scanning (ps on Unix, wmic on Windows), probes their health endpoints,
+ * and either attaches to a live instance or launches a new one on port 4096.
+ *
+ * If multiple live instances are found an interactive numbered selector is shown.
+ */
+
+const DEFAULT_PORT = 4096;
+const DEFAULT_HOST = "127.0.0.1";
+const HEALTH_TIMEOUT_MS = 800;
+
+function printHelp() {
+  process.stdout.write(`oc
+
+Usage:
+  oc [opencode args...]
+
+Environment variables:
+  OPENCODE_LOCAL_PORT   Force a specific port
+  OPENCODE_HOST         Force a specific host
+
+Behavior:
+  Auto-discovers running OpenCode instances and attaches when possible.
+  Launches a new instance on port 4096 when none is available.
+`);
+}
+
+// ── Types ─────────────────────────────────────────────────────────────────────
+
+interface Candidate {
+  url: string;
+  pid?: number;
+}
+
+// ── Process scanning ──────────────────────────────────────────────────────────
+
+function scanProcessesUnix(): Candidate[] {
+  const proc = Bun.spawnSync(["ps", "-ax", "-o", "pid=,command="], {
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  if (proc.exitCode !== 0) return [];
+
+  const output = Buffer.from(proc.stdout).toString("utf8");
+  return parseProcessLines(output, /^\s*(\d+)\s+(.*)$/);
+}
+
+function scanProcessesWindows(): Candidate[] {
+  const proc = Bun.spawnSync(
+    ["wmic", "process", "get", "ProcessId,CommandLine", "/format:csv"],
+    { stdout: "pipe", stderr: "pipe" },
+  );
+  if (proc.exitCode !== 0) return [];
+
+  const output = Buffer.from(proc.stdout).toString("utf8");
+  const candidates: Candidate[] = [];
+
+  for (const line of output.split(/\r?\n/).filter(Boolean)) {
+    // CSV columns: Node,CommandLine,ProcessId
+    const cols = line.split(",");
+    if (cols.length < 3) continue;
+    const command = cols.slice(1, -1).join(","); // CommandLine may contain commas
+    const pidStr = cols[cols.length - 1] ?? "";
+    const pid = Number.parseInt(pidStr.trim(), 10);
+    if (Number.isNaN(pid)) continue;
+
+    const candidate = extractFromCommand(command, pid);
+    if (candidate) candidates.push(candidate);
+  }
+
+  return candidates;
+}
+
+function parseProcessLines(
+  output: string,
+  linePattern: RegExp,
+): Candidate[] {
+  const candidates: Candidate[] = [];
+
+  for (const line of output.split(/\r?\n/).filter(Boolean)) {
+    const match = line.match(linePattern);
+    if (!match) continue;
+    const pid = Number.parseInt(match[1] ?? "", 10);
+    const command = match[2] ?? "";
+    const candidate = extractFromCommand(command, pid);
+    if (candidate) candidates.push(candidate);
+  }
+
+  return candidates;
+}
+
+function extractFromCommand(command: string, pid: number): Candidate | null {
+  const isServe = /\bopencode\b.*\bserve\b/i.test(command);
+  const isTuiWithPort =
+    /\bopencode\b/i.test(command) &&
+    /--port[=\s]+([1-9]\d*)/.test(command) &&
+    !/\bserve\b/i.test(command);
+
+  if (!isServe && !isTuiWithPort) return null;
+
+  const portMatch = command.match(/--port[=\s]+(\d+)/);
+  const hostMatch = command.match(/--hostname[=\s]+(\S+)/);
+  const port = portMatch ? Number.parseInt(portMatch[1] ?? "", 10) : DEFAULT_PORT;
+  const rawHost = hostMatch ? (hostMatch[1] ?? DEFAULT_HOST) : DEFAULT_HOST;
+  // 0.0.0.0 listens on all interfaces — connect via loopback
+  const host = rawHost === "0.0.0.0" ? "127.0.0.1" : rawHost;
+
+  return { url: `http://${host}:${port}`, pid };
+}
+
+function discoverCandidates(): Candidate[] {
+  const raw =
+    process.platform === "win32" ? scanProcessesWindows() : scanProcessesUnix();
+
+  // Deduplicate by URL
+  const seen = new Set<string>();
+  const deduped = raw.filter((c) => {
+    if (seen.has(c.url)) return false;
+    seen.add(c.url);
+    return true;
+  });
+
+  // Always include the default endpoint as a fallback
+  if (!seen.has(`http://${DEFAULT_HOST}:${DEFAULT_PORT}`)) {
+    deduped.push({ url: `http://${DEFAULT_HOST}:${DEFAULT_PORT}` });
+  }
+
+  return deduped;
+}
+
+// ── Health probe ──────────────────────────────────────────────────────────────
+
+async function isAlive(url: string): Promise<boolean> {
+  try {
+    const res = await fetch(`${url}/global/health`, {
+      signal: AbortSignal.timeout(HEALTH_TIMEOUT_MS),
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+
+async function filterAlive(candidates: Candidate[]): Promise<Candidate[]> {
+  const results = await Promise.all(
+    candidates.map(async (c) => ({ candidate: c, alive: await isAlive(c.url) })),
+  );
+  return results.filter((r) => r.alive).map((r) => r.candidate);
+}
+
+// ── Interactive selector ──────────────────────────────────────────────────────
+
+async function selectInstance(candidates: Candidate[]): Promise<Candidate> {
+  const lines = [
+    `Found ${candidates.length} running OpenCode instances:`,
+    ...candidates.map(
+      (c, i) =>
+        `  [${i + 1}] ${c.url}${c.pid !== undefined ? `  (pid ${c.pid})` : ""}`,
+    ),
+    `Select [1-${candidates.length}]: `,
+  ];
+
+  process.stderr.write(lines.join("\n"));
+
+  // Read a line from stdin
+  for (let attempt = 0; attempt < 3; attempt++) {
+    const raw = await readLine();
+    const n = Number.parseInt(raw.trim(), 10);
+    if (!Number.isNaN(n) && n >= 1 && n <= candidates.length) {
+      return candidates[n - 1]!;
+    }
+    if (attempt < 2) {
+      process.stderr.write(`Invalid choice. Select [1-${candidates.length}]: `);
+    }
+  }
+
+  process.stderr.write("\nInvalid selection. Exiting.\n");
+  process.exit(1);
+}
+
+function readLine(): Promise<string> {
+  return new Promise((resolve) => {
+    let buffer = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.resume();
+    process.stdin.once("data", (chunk: string) => {
+      process.stdin.pause();
+      buffer += chunk;
+      resolve(buffer.split("\n")[0] ?? "");
+    });
+  });
+}
+
+// ── Spawn helpers ─────────────────────────────────────────────────────────────
+
+async function run(cmd: string[]): Promise<void> {
+  const proc = Bun.spawn(cmd, {
+    stdio: ["inherit", "inherit", "inherit"],
+  });
+  const code = await proc.exited;
+  process.exit(code ?? 0);
+}
+
+function hasDirFlag(args: string[]): boolean {
+  return args.includes("--dir") || args.some((arg) => arg.startsWith("--dir="));
+}
+
+function hasProjectArg(args: string[]): boolean {
+  const first = args[0];
+  return first !== undefined && !first.startsWith("-");
+}
+
+export function buildAttachCommand(url: string, extraArgs: string[], cwd: string): string[] {
+  return hasDirFlag(extraArgs)
+    ? ["opencode", "attach", url, ...extraArgs]
+    : ["opencode", "attach", url, "--dir", cwd, ...extraArgs];
+}
+
+export function buildLaunchCommand(extraArgs: string[], cwd: string, port?: string, host?: string): string[] {
+  const args = hasProjectArg(extraArgs) ? [...extraArgs] : [cwd, ...extraArgs];
+  const command = ["opencode", ...args];
+  if (port !== undefined) command.push("--port", port);
+  if (host !== undefined) command.push("--hostname", host);
+  return command;
+}
+
+// ── Main ──────────────────────────────────────────────────────────────────────
+
+async function main(): Promise<void> {
+  const extraArgs = process.argv.slice(2);
+  if (extraArgs.includes("--help") || extraArgs.includes("-h")) {
+    printHelp();
+    process.exit(0);
+  }
+  const cwd = process.cwd();
+
+  const envPort = process.env["OPENCODE_LOCAL_PORT"];
+  const envHost = process.env["OPENCODE_HOST"];
+
+  // ── Explicit mode: both env vars set ───────────────────────────────────────
+  if (envPort !== undefined && envHost !== undefined) {
+    const url = `http://${envHost}:${envPort}`;
+    const alive = await isAlive(url);
+    if (alive) {
+      await run(buildAttachCommand(url, extraArgs, cwd));
+    } else {
+      await run(buildLaunchCommand(extraArgs, cwd, envPort, envHost));
+    }
+    return;
+  }
+
+  // Partial override: only port or only host specified
+  if (envPort !== undefined || envHost !== undefined) {
+    const port = envPort ?? String(DEFAULT_PORT);
+    const host = envHost ?? DEFAULT_HOST;
+    const url = `http://${host}:${port}`;
+    const alive = await isAlive(url);
+    if (alive) {
+      await run(buildAttachCommand(url, extraArgs, cwd));
+    } else {
+      await run(buildLaunchCommand(extraArgs, cwd, port, host));
+    }
+    return;
+  }
+
+  // ── Auto-discovery mode ────────────────────────────────────────────────────
+  const candidates = discoverCandidates();
+  const alive = await filterAlive(candidates);
+
+  if (alive.length === 0) {
+    // Nothing running — launch on default port
+    await run(buildLaunchCommand(extraArgs, cwd, String(DEFAULT_PORT)));
+    return;
+  }
+
+  if (alive.length === 1) {
+    await run(buildAttachCommand(alive[0]!.url, extraArgs, cwd));
+    return;
+  }
+
+  // Multiple instances — show selector
+  const chosen = await selectInstance(alive);
+  await run(buildAttachCommand(chosen.url, extraArgs, cwd));
+}
+
+if (import.meta.main) {
+  await main();
+}
+
+export {};