@companyhelm/runner 0.0.13 → 0.0.15

package/dist/commands/shell.js

@@ -1,14 +1,66 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getShellConfigurableDaemonOptions = getShellConfigurableDaemonOptions;
 exports.buildShellDaemonOverrideArgs = buildShellDaemonOverrideArgs;
+exports.parseShellCommand = parseShellCommand;
 exports.runShellCommand = runShellCommand;
 exports.registerShellCommand = registerShellCommand;
+const p = __importStar(require("@clack/prompts"));
+const drizzle_orm_1 = require("drizzle-orm");
+const node_readline_1 = require("node:readline");
 const config_js_1 = require("../config.js");
+const docker_js_1 = require("./thread/docker.js");
+const daemon_state_js_1 = require("../state/daemon_state.js");
 const db_js_1 = require("../state/db.js");
 const schema_js_1 = require("../state/schema.js");
 const common_js_1 = require("./runner/common.js");
+const terminal_js_1 = require("../utils/terminal.js");
+const path_js_1 = require("../utils/path.js");
 const NON_OVERRIDABLE_DAEMON_OPTION_NAMES = new Set(["daemon", "serverUrl", "secret", "help"]);
+const SHELL_PROMPT = "companyhelm db> ";
+const SHELL_HELP_TEXT = [
+    "Available commands:",
+    "  help                 Show this help.",
+    "  list threads         List full thread rows from the state DB.",
+    "  thread status <id>   Show the full thread row for one thread.",
+    "  list containers      List thread container fields from the state DB.",
+    "  thread docker <id>   Docker exec bash into the selected thread runtime container.",
+    "  show daemon          Show the daemon_state row from the state DB.",
+    "  exit                 Exit the shell.",
+].join("\n");
 function resolveDaemonOptionValue(option, values) {
     const explicit = values[option.name];
     if (explicit !== undefined) {
@@ -63,28 +115,264 @@ function buildShellDaemonOverrideArgs(options, values) {
     }
     return args;
 }
-async function assertConfiguredSdks(cfg) {
+function jsonReplacer(_key, value) {
+    return typeof value === "bigint" ? value.toString() : value;
+}
+function printRows(label, rows) {
+    console.log();
+    console.log(`${label}:`);
+    if (rows.length === 0) {
+        console.log("  - none");
+        console.log();
+        return;
+    }
+    for (const row of rows) {
+        console.log(JSON.stringify(row, jsonReplacer, 2));
+    }
+    console.log();
+}
+function printRow(label, row) {
+    console.log();
+    console.log(`${label}:`);
+    console.log(JSON.stringify(row, jsonReplacer, 2));
+    console.log();
+}
+function parseShellCommand(input) {
+    const trimmed = input.trim();
+    if (!trimmed) {
+        return { type: "help" };
+    }
+    const tokens = trimmed.split(/\s+/);
+    const normalized = tokens.map((token) => token.toLowerCase());
+    if (normalized.length === 1) {
+        switch (normalized[0]) {
+            case "help":
+            case "?":
+                return { type: "help" };
+            case "threads":
+                return { type: "list-threads" };
+            case "containers":
+                return { type: "list-containers" };
+            case "daemon":
+                return { type: "show-daemon" };
+            case "exit":
+            case "quit":
+                return { type: "exit" };
+            default:
+                return { type: "unknown", input: trimmed };
+        }
+    }
+    if (normalized.length === 2) {
+        if (normalized[0] === "list" && normalized[1] === "threads") {
+            return { type: "list-threads" };
+        }
+        if (normalized[0] === "list" && normalized[1] === "containers") {
+            return { type: "list-containers" };
+        }
+        if (normalized[0] === "show" && normalized[1] === "daemon") {
+            return { type: "show-daemon" };
+        }
+        if (normalized[0] === "status") {
+            return { type: "thread-status", threadId: tokens[1] };
+        }
+    }
+    if (normalized.length >= 3 && normalized[0] === "thread" && normalized[1] === "status") {
+        return { type: "thread-status", threadId: tokens.slice(2).join(" ") };
+    }
+    if (normalized.length >= 3 && normalized[0] === "thread" && normalized[1] === "docker") {
+        return { type: "thread-docker-shell", threadId: tokens.slice(2).join(" ") };
+    }
+    if (normalized.length >= 3 && normalized[0] === "docker" && normalized[1] === "shell") {
+        return { type: "thread-docker-shell", threadId: tokens.slice(2).join(" ") };
+    }
+    return { type: "unknown", input: trimmed };
+}
+async function selectThreadId(db, message) {
+    const rows = await db
+        .select({
+        id: schema_js_1.threads.id,
+        status: schema_js_1.threads.status,
+        model: schema_js_1.threads.model,
+    })
+        .from(schema_js_1.threads)
+        .orderBy(schema_js_1.threads.id)
+        .all();
+    if (rows.length === 0) {
+        p.log.warn("No threads found.");
+        return null;
+    }
+    const selection = await p.select({
+        message,
+        options: rows.map((row) => ({
+            value: row.id,
+            label: row.id,
+            hint: `status=${row.status} model=${row.model}`,
+        })),
+    });
+    return p.isCancel(selection) ? null : selection;
+}
+async function promptShellAction() {
+    const action = await p.select({
+        message: "Choose shell action",
+        options: [
+            { value: "list-threads", label: "List threads" },
+            { value: "thread-status", label: "Thread status" },
+            { value: "list-containers", label: "List containers" },
+            { value: "thread-docker-shell", label: "Thread docker shell (bash)" },
+            { value: "show-daemon", label: "Show daemon state" },
+            { value: "help", label: "Show help" },
+            { value: "exit", label: "Exit shell" },
+        ],
+    });
+    return p.isCancel(action) ? null : action;
+}
+async function runClackShell(db, stateDbPath) {
+    p.intro(`CompanyHelm DB shell\n${(0, path_js_1.expandHome)(stateDbPath)}`);
+    try {
+        while (true) {
+            const action = await promptShellAction();
+            if (!action || action === "exit") {
+                p.outro("Shell closed.");
+                return;
+            }
+            try {
+                switch (action) {
+                    case "help":
+                        console.log(SHELL_HELP_TEXT);
+                        break;
+                    case "list-threads":
+                        await runParsedShellCommand(db, { type: "list-threads" });
+                        break;
+                    case "thread-status": {
+                        const threadId = await selectThreadId(db, "Select thread");
+                        if (!threadId) {
+                            break;
+                        }
+                        await runParsedShellCommand(db, { type: "thread-status", threadId });
+                        break;
+                    }
+                    case "list-containers":
+                        await runParsedShellCommand(db, { type: "list-containers" });
+                        break;
+                    case "thread-docker-shell": {
+                        const threadId = await selectThreadId(db, "Select thread for docker bash");
+                        if (!threadId) {
+                            break;
+                        }
+                        (0, terminal_js_1.restoreInteractiveTerminalState)();
+                        await (0, docker_js_1.runThreadDockerCommand)({ threadId });
+                        break;
+                    }
+                    case "show-daemon":
+                        await runParsedShellCommand(db, { type: "show-daemon" });
+                        break;
+                    default:
+                        break;
+                }
+            }
+            catch (error) {
+                p.log.error(error instanceof Error ? error.message : String(error));
+            }
+        }
+    }
+    finally {
+        (0, terminal_js_1.restoreInteractiveTerminalState)();
+    }
+}
+async function runParsedShellCommand(db, command) {
+    switch (command.type) {
+        case "help":
+            console.log(SHELL_HELP_TEXT);
+            return false;
+        case "list-threads": {
+            const rows = await db.select().from(schema_js_1.threads).orderBy(schema_js_1.threads.id).all();
+            printRows("Threads", rows);
+            return false;
+        }
+        case "thread-status": {
+            const row = await db.select().from(schema_js_1.threads).where((0, drizzle_orm_1.eq)(schema_js_1.threads.id, command.threadId)).get();
+            if (!row) {
+                console.log(`Thread '${command.threadId}' was not found.`);
+                return false;
+            }
+            printRow(`Thread '${command.threadId}'`, row);
+            return false;
+        }
+        case "list-containers": {
+            const rows = await db
+                .select({
+                threadId: schema_js_1.threads.id,
+                status: schema_js_1.threads.status,
+                isCurrentTurnRunning: schema_js_1.threads.isCurrentTurnRunning,
+                runtimeContainer: schema_js_1.threads.runtimeContainer,
+                dindContainer: schema_js_1.threads.dindContainer,
+                workspace: schema_js_1.threads.workspace,
+            })
+                .from(schema_js_1.threads)
+                .orderBy(schema_js_1.threads.id)
+                .all();
+            printRows("Containers", rows);
+            return false;
+        }
+        case "thread-docker-shell":
+            (0, terminal_js_1.restoreInteractiveTerminalState)();
+            await (0, docker_js_1.runThreadDockerCommand)({ threadId: command.threadId });
+            return false;
+        case "show-daemon": {
+            const row = await db.select().from(schema_js_1.daemonState).where((0, drizzle_orm_1.eq)(schema_js_1.daemonState.id, daemon_state_js_1.RUNNER_DAEMON_STATE_ID)).get();
+            if (!row) {
+                console.log("Daemon state: none");
+                return false;
+            }
+            printRow("Daemon state", row);
+            return false;
+        }
+        case "exit":
+            return true;
+        case "unknown":
+            console.log(`Unknown command: ${command.input}`);
+            console.log("Use 'help' to see available commands.");
+            return false;
+        default:
+            return false;
+    }
+}
+async function runShellCommand(options = {}) {
+    const cfg = config_js_1.config.parse({
+        state_db_path: options.stateDbPath,
+    });
     const { db, client } = await (0, db_js_1.initDb)(cfg.state_db_path);
+    const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
     try {
-        const configuredSdks = await db.select().from(schema_js_1.agentSdks).all();
-        if (configuredSdks.length === 0) {
-            throw new Error("No SDKs configured. Daemon mode requires at least one configured SDK.");
+        if (interactive) {
+            await runClackShell(db, cfg.state_db_path);
+            return;
+        }
+        const rl = (0, node_readline_1.createInterface)({
+            input: process.stdin,
+            output: process.stdout,
+            terminal: false,
+            historySize: 0,
+        });
+        console.log(`State DB: ${(0, path_js_1.expandHome)(cfg.state_db_path)}`);
+        console.log(SHELL_HELP_TEXT);
+        for await (const line of rl) {
+            const shouldExit = await runParsedShellCommand(db, parseShellCommand(line));
+            if (shouldExit) {
+                break;
+            }
         }
     }
     finally {
         client.close();
     }
 }
-async function runShellCommand(_program) {
-    const cfg = config_js_1.config.parse({});
-    await assertConfiguredSdks(cfg);
-    throw new Error("Interactive shell is no longer supported. Use the daemon mode entrypoint.");
-}
 function registerShellCommand(program) {
     program
         .command("shell")
-        .description("Start an interactive protobuf shell against a local companyhelm-runner daemon process.")
-        .action(async () => {
-        await runShellCommand(program);
+        .description("Open an interactive shell for inspecting local state and entering thread runtime containers.")
+        .option("--state-db-path <path>", "State database path override (defaults to state.db under the active config directory).")
+        .action(async (options) => {
+        await runShellCommand(options);
     });
 }

package/dist/service/app_server.js

@@ -113,6 +113,9 @@ class AppServerService {
     async readThread(params) {
         return this.request("thread/read", params, 15000);
     }
+    async loginAccount(params) {
+        return this.request("account/login/start", params, 15000);
+    }
     async startTurn(params) {
         return this.request("turn/start", params, 15000);
     }

package/dist/state/schema.js

@@ -8,6 +8,7 @@ exports.agentSdks = (0, sqlite_core_1.sqliteTable)("agent_sdks", {
     authentication: (0, sqlite_core_1.text)("authentication", {
         enum: ["unauthenticated", "host", "dedicated", "api-key"],
     }).notNull(),
+    status: (0, sqlite_core_1.text)("status", { enum: ["unconfigured", "configured"] }).notNull(),
 });
 // ── llm_models ──────────────────────────────────────────────────────────────
 exports.llmModels = (0, sqlite_core_1.sqliteTable)("llm_models", {

package/drizzle/0002_kind_sue_storm.sql

@@ -1 +1,45 @@
-ALTER TABLE `threads` ADD `status` text NOT NULL;
+PRAGMA foreign_keys=OFF;--> statement-breakpoint
+DROP TABLE IF EXISTS `__new_threads`;--> statement-breakpoint
+CREATE TABLE `__new_threads` (
+	`id` text PRIMARY KEY NOT NULL,
+	`agent_id` text NOT NULL,
+	`model` text NOT NULL,
+	`reasoning_level` text NOT NULL,
+	`status` text NOT NULL,
+	`workspace` text NOT NULL,
+	`runtime_container` text NOT NULL,
+	`dind_container` text NOT NULL,
+	`home_directory` text NOT NULL,
+	`uid` integer NOT NULL,
+	`gid` integer NOT NULL,
+	FOREIGN KEY (`agent_id`) REFERENCES `agents`(`id`) ON UPDATE no action ON DELETE no action
+);
+--> statement-breakpoint
+INSERT INTO `__new_threads`(
+	"id",
+	"agent_id",
+	"model",
+	"reasoning_level",
+	"status",
+	"workspace",
+	"runtime_container",
+	"dind_container",
+	"home_directory",
+	"uid",
+	"gid"
+) SELECT
+	"id",
+	"agent_id",
+	"model",
+	"reasoning_level",
+	'ready' AS "status",
+	"workspace",
+	"runtime_container",
+	"dind_container",
+	"home_directory",
+	"uid",
+	"gid"
+FROM `threads`;--> statement-breakpoint
+DROP TABLE `threads`;--> statement-breakpoint
+ALTER TABLE `__new_threads` RENAME TO `threads`;--> statement-breakpoint
+PRAGMA foreign_keys=ON;

package/drizzle/0012_magenta_chameleon.sql

@@ -0,0 +1,19 @@
+PRAGMA foreign_keys=OFF;--> statement-breakpoint
+DROP TABLE IF EXISTS `__new_agent_sdks`;--> statement-breakpoint
+CREATE TABLE `__new_agent_sdks` (
+	`name` text PRIMARY KEY NOT NULL,
+	`authentication` text NOT NULL,
+	`status` text NOT NULL
+);
+--> statement-breakpoint
+INSERT INTO `__new_agent_sdks`("name", "authentication", "status") SELECT
+	"name",
+	"authentication",
+	CASE
+		WHEN "authentication" = 'unauthenticated' THEN 'unconfigured'
+		ELSE 'configured'
+	END AS "status"
+FROM `agent_sdks`;--> statement-breakpoint
+DROP TABLE `agent_sdks`;--> statement-breakpoint
+ALTER TABLE `__new_agent_sdks` RENAME TO `agent_sdks`;--> statement-breakpoint
+PRAGMA foreign_keys=ON;