@cjhyy/code-shell-core 0.5.0-rc.1 → 0.5.0-rc.2

package/dist/cli/agent-server-tcp.js

@@ -0,0 +1,120 @@
+/**
+ * agent-server-tcp — headless server entry point over TCP (Phase 6).
+ *
+ * Mirrors agent-server-stdio.ts (same EngineRuntime + ChatSessionManager +
+ * AgentServer bootstrap), but listens on a TCP socket instead of stdio and
+ * also starts the in-process automation scheduler so a deployed server runs
+ * scheduled jobs 7x24 with no Electron/GUI.
+ *
+ * The automation module is the SAME zero-env-dependency module the desktop
+ * loads (startAutomation) — this is the "thin server host" the plan's D2
+ * describes: one module, two hosts.
+ *
+ * Usage:
+ *   AGENT_TCP_PORT=4321 node dist/cli/agent-server-tcp.js
+ *
+ * v1 SECURITY: binds 127.0.0.1 by default and has NO authentication. Do not
+ * expose to a public interface without adding auth (token/TLS). Use SSH
+ * tunneling for remote access in v1.
+ */
+import { Engine } from "../engine/engine.js";
+import { EngineRuntime } from "../engine/runtime.js";
+import { ChatSessionManager } from "../protocol/chat-session-manager.js";
+import { AgentServer } from "../protocol/server.js";
+import { listenTcp } from "../protocol/tcp-transport.js";
+import { SettingsManager } from "../settings/manager.js";
+import { personalizationFrom } from "../settings/personalization.js";
+import { MCPManager } from "../tool-system/mcp-manager.js";
+import { mergePluginMcpServers } from "../plugins/installer/loadPluginMcp.js";
+import { CostTracker } from "../cost-tracker.js";
+import { HeadlessApprovalBackend } from "../tool-system/permission.js";
+import { createRunManager } from "../run/factory.js";
+import { startAutomation } from "../automation/index.js";
+import { CronStore, defaultCronStorePath } from "../automation/store.js";
+const cwd = process.env.AGENT_CWD ?? process.cwd();
+const port = Number(process.env.AGENT_TCP_PORT ?? "4321");
+const host = process.env.AGENT_TCP_HOST ?? "127.0.0.1";
+const settingsManager = new SettingsManager(cwd, "full");
+const settings = settingsManager.get();
+const llmConfig = {
+    provider: settings.model.provider,
+    model: settings.model.name,
+    apiKey: settings.model.apiKey ?? "",
+    baseUrl: settings.model.baseUrl,
+    maxTokens: settings.model.maxTokens,
+};
+// ── Shared runtime (same bootstrap as stdio) ─────────────────────
+const seedEngine = new Engine({ llm: llmConfig, cwd, settingsScope: "full" });
+const modelPool = seedEngine.getModelPool();
+const toolRegistry = seedEngine.getToolRegistry();
+const resolvedLlmConfig = seedEngine.getConfig().llm;
+const resolvedClientDefaults = seedEngine.getConfig().clientDefaults;
+const mcpPool = new MCPManager(toolRegistry);
+const costTracker = new CostTracker();
+const runtime = new EngineRuntime({
+    modelPool,
+    toolRegistry,
+    settings: settingsManager,
+    mcpPool,
+    costTracker,
+});
+const chatManager = new ChatSessionManager({
+    runtime,
+    engineFactory: (slice) => new Engine({
+        llm: runtime.modelPool.resolveLLMConfig() ?? resolvedLlmConfig,
+        clientDefaults: resolvedClientDefaults,
+        cwd,
+        runtime,
+        settingsScope: "full",
+        mcpServers: mergePluginMcpServers(settings.mcpServers ?? {}, settings.disabledPlugins ?? []),
+        permissionMode: slice.permissionMode,
+        preset: slice.preset,
+        customSystemPrompt: slice.customSystemPrompt,
+        appendSystemPrompt: slice.appendSystemPrompt,
+        // Personalization + instruction compat come from disk settings only
+        // (not per-request slice overrides) — same disk-only contract as the
+        // stdio host. Shared helper keeps the three fields wired identically.
+        ...personalizationFrom(settings.agent),
+        maxTurns: slice.maxTurns,
+        maxContextTokens: slice.maxContextTokens,
+        ...(slice.cwd ? { cwd: slice.cwd } : {}),
+    }),
+    maxSessions: 16,
+    idleTtlMs: 30 * 60 * 1000,
+});
+chatManager.startIdleSweeper();
+// ── Automation (same module the desktop loads) ──────────────────
+// Read-only by default until write tiers are configured per job. Runs land in
+// the RunStore so history is queryable.
+const automationRunManager = createRunManager({
+    llm: resolvedLlmConfig,
+    cwd,
+    permissionMode: "default",
+    approvalBackend: new HeadlessApprovalBackend("approve-read-only"),
+});
+const automation = startAutomation({
+    store: new CronStore(defaultCronStorePath()),
+    runManager: automationRunManager,
+});
+// ── Serve over TCP ──────────────────────────────────────────────
+// One AgentServer per accepted connection, all sharing the same chatManager.
+const servers = new Set();
+listenTcp({ port, host }, (transport) => {
+    const server = new AgentServer({ chatManager, transport });
+    servers.add(server);
+})
+    .then((listener) => {
+    process.stderr.write(`[code-shell] automation server listening on ${host}:${listener.port}\n`);
+    const shutdown = () => {
+        automation.stop();
+        for (const s of servers)
+            s.close();
+        void listener.close().then(() => process.exit(0));
+    };
+    process.on("SIGTERM", shutdown);
+    process.on("SIGINT", shutdown);
+})
+    .catch((err) => {
+    process.stderr.write(`[code-shell] failed to start automation server: ${String(err)}\n`);
+    process.exit(1);
+});

package/dist/cli/graceful-shutdown.d.ts

@@ -0,0 +1,27 @@
+/** Minimal surface we need from a server to shut it down cleanly. */
+interface Closable {
+    close(): void;
+}
+/** Minimal surface we need from `process` (injectable for tests). */
+interface ProcLike {
+    on(event: string, listener: (...args: unknown[]) => void): unknown;
+    exit(code?: number): void;
+}
+export interface GracefulShutdownOptions {
+    /** Defaults to the real `process`. */
+    proc?: ProcLike;
+    /** Signals to handle. Defaults to SIGTERM, SIGINT, SIGHUP. */
+    signals?: string[];
+}
+/**
+ * Register signal handlers that cleanly shut down a long-lived server before
+ * the process exits. Without this, SIGTERM/SIGINT (Ctrl+C)/SIGHUP terminate
+ * the process immediately, leaking the idle sweeper interval, open sessions,
+ * pending approvals, and child processes (MCP servers, tools).
+ *
+ * Idempotent: the first signal runs close() exactly once; later signals (or a
+ * second handler firing) are ignored. A throwing close() is swallowed so the
+ * process still exits.
+ */
+export declare function installGracefulShutdown(server: Closable, options?: GracefulShutdownOptions): void;
+export {};

package/dist/cli/graceful-shutdown.js

@@ -0,0 +1,30 @@
+/**
+ * Register signal handlers that cleanly shut down a long-lived server before
+ * the process exits. Without this, SIGTERM/SIGINT (Ctrl+C)/SIGHUP terminate
+ * the process immediately, leaking the idle sweeper interval, open sessions,
+ * pending approvals, and child processes (MCP servers, tools).
+ *
+ * Idempotent: the first signal runs close() exactly once; later signals (or a
+ * second handler firing) are ignored. A throwing close() is swallowed so the
+ * process still exits.
+ */
+export function installGracefulShutdown(server, options = {}) {
+    const proc = options.proc ?? globalThis.process;
+    const signals = options.signals ?? ["SIGTERM", "SIGINT", "SIGHUP"];
+    let shuttingDown = false;
+    const shutdown = () => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        try {
+            server.close();
+        }
+        catch {
+            // Best-effort cleanup — never block exit on a close() failure.
+        }
+        proc.exit(0);
+    };
+    for (const sig of signals) {
+        proc.on(sig, shutdown);
+    }
+}

package/dist/context/compaction.js

@@ -299,28 +299,36 @@ export function applyToolResultBudget(messages, maxTotalChars = 100_000) {
             return msg;
         // Sort by size descending — truncate largest first
         resultBlocks.sort((a, b) => b.size - a.size);
+        // Build the exact replacement for a block, so the running budget uses the
+        // real post-truncation length (the old code assumed a flat ~200 chars,
+        // but the replacement is ~150 boilerplate + up to 500 preview ≈ 650+,
+        // which under-truncated and could even leave the message LARGER).
+        const truncate = (content) => {
+            const preview = content.slice(0, 500);
+            const sizeKb = (content.length / 1000).toFixed(0);
+            return (`Output too large (${sizeKb}KB) — truncated to fit the per-message budget. ` +
+                `Re-run the originating tool if you need the full output.\n\n` +
+                `Preview (first 500 chars):\n${preview}`);
+        };
         let remaining = totalSize;
-        const toTruncate = new Set();
+        const replacements = new Map();
         for (const rb of resultBlocks) {
             if (remaining <= maxTotalChars)
                 break;
-            toTruncate.add(rb.index);
-            remaining -= rb.size;
-            remaining += 200; // truncated replacement is ~200 chars
+            const original = msg.content[rb.index].content;
+            const replaced = truncate(original);
+            // Only truncate if it actually shrinks the block; otherwise skip it
+            // (truncating a barely-oversized block would grow the message).
+            if (replaced.length >= rb.size)
+                continue;
+            replacements.set(rb.index, replaced);
+            remaining -= rb.size - replaced.length;
         }
-        if (toTruncate.size === 0)
+        if (replacements.size === 0)
             return msg;
         const newContent = msg.content.map((block, i) => {
-            if (!toTruncate.has(i))
-                return block;
-            const preview = typeof block.content === "string" ? block.content.slice(0, 500) : "";
-            const sizeKb = (block.content.length / 1000).toFixed(0);
-            return {
-                ...block,
-                content: `Output too large (${sizeKb}KB) — truncated to fit the per-message budget. ` +
-                    `Re-run the originating tool if you need the full output.\n\n` +
-                    `Preview (first 500 chars):\n${preview}`,
-            };
+            const replaced = replacements.get(i);
+            return replaced === undefined ? block : { ...block, content: replaced };
         });
         return { ...msg, content: newContent };
     });

package/dist/context/manager.d.ts

@@ -39,7 +39,6 @@ export type OnCompactFn = (info: {
 }) => void;
 export declare class ContextManager {
     private config;
-    private toolCallHashes;
     private summarizeFn;
     private consecutiveSummaryFailures;
     private lastSummary;
@@ -123,23 +122,4 @@ export declare class ContextManager {
         needsCompact: boolean;
         needsEmergency: boolean;
     };
-    /**
-     * Deduplicate tool calls by hashing arguments.
-     */
-    deduplicateToolCalls(calls: Array<{
-        toolName: string;
-        args: Record<string, unknown>;
-    }>): {
-        toExecute: typeof calls;
-        cached: Array<{
-            toolName: string;
-            args: Record<string, unknown>;
-            result: string;
-        }>;
-    };
-    /**
-     * Record a tool call result for dedup tracking.
-     */
-    recordToolResult(toolName: string, args: Record<string, unknown>, result: string): void;
-    private hashCall;
 }

package/dist/context/manager.js

@@ -39,7 +39,6 @@ function defaultKeepRecent(maxTokens) {
 }
 export class ContextManager {
     config;
-    toolCallHashes = new Map();
     summarizeFn;
     consecutiveSummaryFailures = 0;
     lastSummary;
@@ -384,40 +383,4 @@ export class ContextManager {
             needsEmergency: ratio >= this.config.summarizeAtRatio,
         };
     }
-    /**
-     * Deduplicate tool calls by hashing arguments.
-     */
-    deduplicateToolCalls(calls) {
-        const toExecute = [];
-        const cached = [];
-        for (const call of calls) {
-            const hash = this.hashCall(call.toolName, call.args);
-            const existing = this.toolCallHashes.get(hash);
-            if (existing && existing.count >= 2) {
-                cached.push({ ...call, result: existing.lastResult });
-                existing.count++;
-            }
-            else {
-                toExecute.push(call);
-            }
-        }
-        return { toExecute, cached };
-    }
-    /**
-     * Record a tool call result for dedup tracking.
-     */
-    recordToolResult(toolName, args, result) {
-        const hash = this.hashCall(toolName, args);
-        const existing = this.toolCallHashes.get(hash);
-        if (existing) {
-            existing.count++;
-            existing.lastResult = result;
-        }
-        else {
-            this.toolCallHashes.set(hash, { count: 1, lastResult: result });
-        }
-    }
-    hashCall(toolName, args) {
-        return `${toolName}:${JSON.stringify(args)}`;
-    }
 }

package/dist/cron/cron-runtime.d.ts

@@ -0,0 +1,2 @@
+/** Back-compat shim — moved to `automation/runner.ts`. */
+export * from "../automation/runner.js";

package/dist/cron/cron-runtime.js

@@ -0,0 +1,2 @@
+/** Back-compat shim — moved to `automation/runner.ts`. */
+export * from "../automation/runner.js";

package/dist/cron/cron-store.d.ts

@@ -0,0 +1,2 @@
+/** Back-compat shim — moved to `automation/store.ts`. */
+export * from "../automation/store.js";

package/dist/cron/cron-store.js

@@ -0,0 +1,2 @@
+/** Back-compat shim — moved to `automation/store.ts`. */
+export * from "../automation/store.js";

package/dist/cron/scheduler.d.ts

@@ -1,34 +1,7 @@
 /**
- * Cron scheduler — schedule and manage recurring agent tasks.
- *
- * Supports simple cron-like intervals. Each job runs the Engine
- * with a predefined prompt on schedule.
+ * Back-compat shim. The cron scheduler moved to `automation/scheduler.ts`
+ * (see docs/automation-plan-2026-05-31.md). This re-export keeps existing
+ * `../cron/scheduler.js` importers working. New code should import from
+ * `../automation/scheduler.js`.
  */
-export interface CronJob {
-    id: string;
-    name: string;
-    schedule: string;
-    prompt: string;
-    enabled: boolean;
-    lastRun?: number;
-    nextRun?: number;
-    runCount: number;
-    createdAt: number;
-}
-declare class CronScheduler {
-    private jobs;
-    private timers;
-    private nextId;
-    private onExecute?;
-    setExecutor(fn: (job: CronJob) => Promise<void>): void;
-    create(name: string, schedule: string, prompt: string): CronJob;
-    delete(id: string): boolean;
-    list(): CronJob[];
-    get(id: string): CronJob | undefined;
-    pause(id: string): boolean;
-    resume(id: string): boolean;
-    stopAll(): void;
-    private startTimer;
-}
-export declare const cronScheduler: CronScheduler;
-export {};
+export * from "../automation/scheduler.js";

package/dist/cron/scheduler.js

@@ -1,115 +1,7 @@
 /**
- * Cron scheduler — schedule and manage recurring agent tasks.
- *
- * Supports simple cron-like intervals. Each job runs the Engine
- * with a predefined prompt on schedule.
+ * Back-compat shim. The cron scheduler moved to `automation/scheduler.ts`
+ * (see docs/automation-plan-2026-05-31.md). This re-export keeps existing
+ * `../cron/scheduler.js` importers working. New code should import from
+ * `../automation/scheduler.js`.
  */
-class CronScheduler {
-    jobs = new Map();
-    timers = new Map();
-    nextId = 1;
-    onExecute;
-    setExecutor(fn) {
-        this.onExecute = fn;
-    }
-    create(name, schedule, prompt) {
-        const id = String(this.nextId++);
-        const intervalMs = parseSchedule(schedule);
-        const job = {
-            id,
-            name,
-            schedule,
-            prompt,
-            enabled: true,
-            nextRun: Date.now() + intervalMs,
-            runCount: 0,
-            createdAt: Date.now(),
-        };
-        this.jobs.set(id, job);
-        this.startTimer(job, intervalMs);
-        return job;
-    }
-    delete(id) {
-        const timer = this.timers.get(id);
-        if (timer) {
-            clearInterval(timer);
-            this.timers.delete(id);
-        }
-        return this.jobs.delete(id);
-    }
-    list() {
-        return [...this.jobs.values()];
-    }
-    get(id) {
-        return this.jobs.get(id);
-    }
-    pause(id) {
-        const job = this.jobs.get(id);
-        if (!job)
-            return false;
-        job.enabled = false;
-        const timer = this.timers.get(id);
-        if (timer) {
-            clearInterval(timer);
-            this.timers.delete(id);
-        }
-        return true;
-    }
-    resume(id) {
-        const job = this.jobs.get(id);
-        if (!job)
-            return false;
-        job.enabled = true;
-        const intervalMs = parseSchedule(job.schedule);
-        this.startTimer(job, intervalMs);
-        return true;
-    }
-    stopAll() {
-        for (const timer of this.timers.values()) {
-            clearInterval(timer);
-        }
-        this.timers.clear();
-    }
-    startTimer(job, intervalMs) {
-        if (this.timers.has(job.id)) {
-            clearInterval(this.timers.get(job.id));
-        }
-        const timer = setInterval(async () => {
-            if (!job.enabled)
-                return;
-            job.lastRun = Date.now();
-            job.runCount++;
-            job.nextRun = Date.now() + intervalMs;
-            try {
-                await this.onExecute?.(job);
-            }
-            catch {
-                // Job execution failed — continue scheduling
-            }
-        }, intervalMs);
-        this.timers.set(job.id, timer);
-    }
-}
-/**
- * Parse a schedule string into milliseconds.
- * Supports: "30s", "5m", "1h", "1d", or raw milliseconds.
- */
-function parseSchedule(schedule) {
-    const match = schedule.match(/^(\d+)(s|m|h|d)$/);
-    if (match) {
-        const value = parseInt(match[1], 10);
-        switch (match[2]) {
-            case "s": return value * 1000;
-            case "m": return value * 60 * 1000;
-            case "h": return value * 60 * 60 * 1000;
-            case "d": return value * 24 * 60 * 60 * 1000;
-        }
-    }
-    // Try raw number (milliseconds)
-    const ms = parseInt(schedule, 10);
-    if (!isNaN(ms) && ms > 0)
-        return ms;
-    // Default: 10 minutes
-    return 10 * 60 * 1000;
-}
-export const cronScheduler = new CronScheduler();
+export * from "../automation/scheduler.js";

package/dist/data/openrouter-sync.js

@@ -47,7 +47,7 @@ export async function syncOpenRouterCatalog(timeoutMs = 15_000) {
         return { ok: true, count: models.length };
     }
     catch (err) {
-        return { ok: false, count: 0, error: err.message };
+        return { ok: false, count: 0, error: err instanceof Error ? err.message : String(err) };
     }
 }
 export { getOpenRouterSnapshot };