@cjhyy/code-shell-core 0.7.1 → 0.8.0

package/dist/engine/run-session-open.js

@@ -0,0 +1,186 @@
+/**
+ * Session open — create-or-resume phase of Engine.runExclusive: the three
+ * valid session shapes, clientMessageId claiming (duplicate submits return
+ * early), user-message append, cold-start summary and the turnSeq bump.
+ */
+import { getCurrentSid, logger } from "../logging/logger.js";
+import { patchOrphanedToolUses } from "./patch-orphaned-tools.js";
+export function openRunSession(args) {
+    const { options } = args;
+    const claimedClientMessageIds = new Set();
+    let session;
+    let messages;
+    let freshImageMessage;
+    let resumedFromDisk = false;
+    const claimClientMessageId = (bundle, clientMessageId, source) => {
+        if (!clientMessageId)
+            return true;
+        if (claimedClientMessageIds.has(clientMessageId) ||
+            bundle.transcript.hasClientMessageId(clientMessageId)) {
+            logger.info("engine.client_message.duplicate_ignored", {
+                sessionId: bundle.state.sessionId,
+                clientMessageId,
+                source,
+            });
+            return false;
+        }
+        claimedClientMessageIds.add(clientMessageId);
+        return true;
+    };
+    if (options?.sessionId && args.sessionManager.exists(options.sessionId)) {
+        resumedFromDisk = true;
+        session = args.sessionManager.resume(options.sessionId);
+        const cachedCompacted = args.cachedCompactedMessages;
+        messages = cachedCompacted ? [...cachedCompacted] : session.transcript.toMessages();
+        // If the previous run was Ctrl+C'd or crashed between an assistant
+        // tool_use and the matching tool_result being persisted, the
+        // loaded sequence is invalid for OpenAI (which 400s on dangling
+        // tool_calls). Patch synthetic tool_results so the next API call
+        // doesn't fail before the turn even starts.
+        const patched = patchOrphanedToolUses(messages);
+        if (patched.gapsPatched > 0) {
+            logger.warn("engine.resume.patched_orphaned_tool_uses", {
+                sessionId: options.sessionId,
+                gaps: patched.gapsPatched,
+                toolResults: patched.toolResultsInjected,
+            });
+        }
+        // Restore cost state from previous session, if the caller injected a store
+        if (session.state.costState && args.costStore) {
+            args.costStore.restore(session.state.costState);
+        }
+        // Append new user message
+        const userMsg = { role: "user", content: args.userMessageContent };
+        if (!claimClientMessageId(session, options?.clientMessageId, "submit")) {
+            const replayed = options?.clientMessageId
+                ? session.transcript.findRunResultByClientMessageId(options.clientMessageId)
+                : undefined;
+            if (replayed) {
+                logger.info("engine.client_message.result_replayed", {
+                    sessionId: session.state.sessionId,
+                    clientMessageId: options?.clientMessageId,
+                });
+                return { ok: false, result: replayed };
+            }
+            const usage = session.state.tokenUsage ?? {
+                promptTokens: 0,
+                completionTokens: 0,
+                totalTokens: 0,
+            };
+            return {
+                ok: false,
+                result: {
+                    text: "",
+                    reason: "completed",
+                    sessionId: session.state.sessionId,
+                    turnCount: session.state.turnCount ?? 0,
+                    usage: {
+                        promptTokens: usage.promptTokens ?? 0,
+                        completionTokens: usage.completionTokens ?? 0,
+                        totalTokens: usage.totalTokens ?? 0,
+                    },
+                },
+            };
+        }
+        if (args.parsedTask.hasImages)
+            freshImageMessage = userMsg;
+        messages.push(userMsg);
+        session.transcript.appendMessage("user", args.userMessageContent, {
+            injected: options?.injected === true,
+            clientMessageId: options?.clientMessageId,
+            displayText: options?.displayText?.trim() || undefined,
+            ...(options?.agentDirection
+                ? {
+                    authority: "agent",
+                    source: "agent-direction",
+                    envelopeIds: options.agentDirection.envelopeIds,
+                    correlationIds: options.agentDirection.correlationIds,
+                }
+                : {}),
+        });
+        if (options?.agentDirection) {
+            args.onAgentDirectionsDelivered?.(options.agentDirection.envelopeIds);
+        }
+        // Flush "active" status to disk immediately. resume() set it in memory
+        // (session-manager.ts), but without this write the on-disk state.json
+        // still shows the previous run's terminal reason — so any external
+        // observer (another CLI process, /sid, the session list) would think
+        // the session is still errored/aborted while we're actually running.
+        args.sessionManager.saveStateOrUpdateFields(session.state, {
+            status: session.state.status,
+        });
+    }
+    else {
+        // Cold start: shape (2) reuses the host-supplied sid; shape (3)
+        // lets sessionManager generate one with nanoid.
+        session = args.sessionManager.create(args.cwd, args.llmModel, args.llmProvider, options?.sessionId, args.isSubAgent ? getCurrentSid() : undefined, args.isSubAgent ? "subagent" : args.origin, args.sessionKind);
+        const userMsg = { role: "user", content: args.userMessageContent };
+        claimClientMessageId(session, options?.clientMessageId, "submit");
+        if (args.parsedTask.hasImages)
+            freshImageMessage = userMsg;
+        messages = [userMsg];
+        session.transcript.appendMessage("user", args.userMessageContent, {
+            injected: options?.injected === true,
+            clientMessageId: options?.clientMessageId,
+            displayText: options?.displayText?.trim() || undefined,
+            ...(options?.agentDirection
+                ? {
+                    authority: "agent",
+                    source: "agent-direction",
+                    envelopeIds: options.agentDirection.envelopeIds,
+                    correlationIds: options.agentDirection.correlationIds,
+                }
+                : {}),
+        });
+        if (options?.agentDirection) {
+            args.onAgentDirectionsDelivered?.(options.agentDirection.envelopeIds);
+        }
+        // Save first user message as session summary — text only. The summary
+        // shows up in the session list; "[image]" is more informative than a
+        // truncated `[object Object]` when the prompt was purely visual.
+        const summarySrc = options?.displayText?.trim() ||
+            (args.parsedTask.hasImages
+                ? args.parsedTask.text ||
+                    `[image${args.parsedTask.images.length > 1 ? `s × ${args.parsedTask.images.length}` : ""}]`
+                : args.taskText);
+        session.state.summary = summarySrc.slice(0, 80).replace(/\n/g, " ");
+        args.sessionManager.saveStateOrUpdateFields(session.state, {
+            summary: session.state.summary,
+        });
+    }
+    // Bump the conversation-turn counter: this user message starts a new turn.
+    // One user message = one turn, regardless of how many turn-loop iterations
+    // or tool calls it spans. File-history snapshots taken below are tagged
+    // with this value so `/undo` reverts exactly this turn's file changes.
+    // (Both resume and cold-start paths converge here.)
+    if (args.sessionWorkspaceProfile &&
+        session.state.workspaceProfile !== args.sessionWorkspaceProfile) {
+        session.state.workspaceProfile = args.sessionWorkspaceProfile;
+        args.sessionManager.saveStateOrUpdateFields(session.state, {
+            workspaceProfile: args.sessionWorkspaceProfile,
+        });
+    }
+    // Same first-write-wins shape as the profile binding: the host resends the
+    // standing brief every turn (a planned Session has no state yet), so persist it
+    // once and let later turns read it from state.
+    if (args.sessionBrief && session.state.sessionBrief !== args.sessionBrief) {
+        session.state.sessionBrief = args.sessionBrief;
+        args.sessionManager.saveStateOrUpdateFields(session.state, {
+            sessionBrief: args.sessionBrief,
+        });
+    }
+    session.state.turnSeq = (session.state.turnSeq ?? 0) + 1;
+    return {
+        ok: true,
+        opened: {
+            session,
+            messages,
+            freshImageMessage,
+            resumedFromDisk,
+            claimClientMessageId,
+            releaseClientMessageId: (id) => {
+                claimedClientMessageIds.delete(id);
+            },
+        },
+    };
+}

package/dist/engine/run-setup.d.ts

@@ -0,0 +1,42 @@
+import type { ComposerOptions } from "../prompt/composer.js";
+import { profileOverridesFromDefinition } from "../profile/activation.js";
+import { resolveActiveWorkspaceProfile } from "../profile/resolve.js";
+import type { WorkspaceProfile } from "../profile/types.js";
+import type { SettingsManager } from "../settings/manager.js";
+export interface RunProfileState {
+    workspaceProfile: ReturnType<typeof resolveActiveWorkspaceProfile>;
+    sessionProfileOverrides: ReturnType<typeof profileOverridesFromDefinition> | undefined;
+    profileMemoryDir: string | undefined;
+}
+/** Resolve the digital-human profile bound to this run (session pin wins). */
+export declare function resolveRunProfileState(args: {
+    sessionWorkspaceProfile: string | undefined;
+    cwd: string;
+    settings: SettingsManager;
+}): RunProfileState;
+export interface RunPromptComposerConfigInput {
+    cwd: ComposerOptions["cwd"];
+    /** Standing brief persisted on the Session (see SessionState.sessionBrief). */
+    sessionBrief?: ComposerOptions["sessionBrief"];
+    model: ComposerOptions["model"];
+    preset: ComposerOptions["preset"];
+    customSystemPrompt: ComposerOptions["customSystemPrompt"];
+    appendSystemPrompt: ComposerOptions["appendSystemPrompt"];
+    responseLanguage: ComposerOptions["responseLanguage"];
+    userProfile: ComposerOptions["userProfile"];
+    workspaceProfile: WorkspaceProfile | undefined;
+    profileMemoryDir: ComposerOptions["profileMemoryDir"];
+    instructionCompatFileNames: NonNullable<NonNullable<ComposerOptions["instructionOptions"]>["compatFileNames"]>;
+    instructionBoundaryFinder: NonNullable<NonNullable<ComposerOptions["instructionOptions"]>["boundaryFinder"]>;
+    disabledSkills: ComposerOptions["disabledSkills"];
+    disabledPlugins: ComposerOptions["disabledPlugins"];
+    skillAllowlist: ComposerOptions["skillAllowlist"];
+    memoriesMaxAgeDays: ComposerOptions["memoriesMaxAgeDays"];
+    goalToolState: ComposerOptions["goalToolState"];
+    capabilityPromptSections: ComposerOptions["capabilityPromptSections"];
+    dynamicContextProviders: ComposerOptions["dynamicContextProviders"];
+    getSettingsManager: () => SettingsManager;
+    toolCatalog: ComposerOptions["toolCatalog"];
+}
+/** Build the prompt-composer options for a run without capturing the Engine facade. */
+export declare function buildPromptComposerConfig(args: RunPromptComposerConfigInput): ComposerOptions;

package/dist/engine/run-setup.js

@@ -0,0 +1,58 @@
+import { profileOverridesFromDefinition } from "../profile/activation.js";
+import { resolveActiveWorkspaceProfile } from "../profile/resolve.js";
+import { workspaceProfileDir } from "../profile/store.js";
+import { buildSourcesContextSummary } from "../sources/context-summary.js";
+/** Resolve the digital-human profile bound to this run (session pin wins). */
+export function resolveRunProfileState(args) {
+    const { sessionWorkspaceProfile, cwd, settings } = args;
+    const workspaceProfile = resolveActiveWorkspaceProfile({
+        ...(sessionWorkspaceProfile ? { sessionProfile: sessionWorkspaceProfile } : {}),
+        cwd,
+        settings,
+    });
+    if (sessionWorkspaceProfile && !workspaceProfile) {
+        throw new Error(`Workspace profile "${sessionWorkspaceProfile}" is unavailable`);
+    }
+    const sessionProfileOverrides = sessionWorkspaceProfile && workspaceProfile
+        ? profileOverridesFromDefinition(workspaceProfile)
+        : undefined;
+    const profileMemoryDir = workspaceProfile?.portableMemory
+        ? workspaceProfileDir(workspaceProfile.name)
+        : undefined;
+    return { workspaceProfile, sessionProfileOverrides, profileMemoryDir };
+}
+/** Build the prompt-composer options for a run without capturing the Engine facade. */
+export function buildPromptComposerConfig(args) {
+    const { cwd, model, preset, customSystemPrompt, appendSystemPrompt, responseLanguage, userProfile, workspaceProfile, sessionBrief, profileMemoryDir, instructionCompatFileNames, instructionBoundaryFinder, disabledSkills, disabledPlugins, skillAllowlist, memoriesMaxAgeDays, goalToolState, capabilityPromptSections, dynamicContextProviders, getSettingsManager, toolCatalog, } = args;
+    return {
+        cwd,
+        model,
+        preset,
+        customSystemPrompt,
+        appendSystemPrompt,
+        responseLanguage,
+        userProfile,
+        // WorkspaceProfile（数字人）：mainInstruction 从库活读（settings 只记名字）。
+        // 命名注意：engine 的局部变量 `profile` 已被 RunBehaviorProfile 占用。
+        profileMainInstruction: workspaceProfile?.mainInstruction,
+        // Only for the "declared but absent" notice; `requires` installs per project,
+        // so a profile summoned where the install never ran would otherwise instruct
+        // the model to call skills that do not exist here.
+        profileDeclaredSkills: workspaceProfile?.skills,
+        sessionBrief,
+        profileMemoryDir,
+        instructionOptions: {
+            compatFileNames: instructionCompatFileNames,
+            boundaryFinder: instructionBoundaryFinder,
+        },
+        disabledSkills,
+        disabledPlugins,
+        skillAllowlist,
+        memoriesMaxAgeDays,
+        goalToolState,
+        capabilityPromptSections,
+        dynamicContextProviders,
+        sourcesContextProvider: () => buildSourcesContextSummary({ cwd, settings: getSettingsManager() }),
+        toolCatalog,
+    };
+}

package/dist/engine/run-tooling.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Run tooling — per-run tool surface assembly for Engine.runExclusive:
+ * ToolContext construction, the permission classifier + executor pipeline,
+ * MCP connection, and the per-turn tool-definition visibility pass.
+ * The sub-agent spawner and sandbox resolution stay in engine.ts (the
+ * `new Engine(` allowlist and RunEnvironmentResolver own them).
+ */
+import type { MCPServerConfig, PermissionMode, TaskInfo, ToolDefinition } from "../types.js";
+import type { SettingsScope } from "../settings/manager.js";
+import type { ToolContext } from "../tool-system/context.js";
+import type { BuiltinToolExposure, BuiltinToolGuard } from "../tool-system/builtin/index.js";
+import { ToolExecutor } from "../tool-system/executor.js";
+import { PermissionClassifier } from "../tool-system/permission.js";
+import { MCPManager } from "../tool-system/mcp-manager.js";
+import type { ToolRegistry } from "../tool-system/registry.js";
+import type { HookRegistry } from "../hooks/registry.js";
+import { isFeatureEnabled, type FeatureFlagName } from "../settings/feature-flags.js";
+import type { CapabilityOverride } from "../settings/schema.js";
+import type { PermissionController } from "./permission-controller.js";
+import type { EngineRunOptions, RunBehaviorProfile } from "./run-types.js";
+/** engine.ts L1485-1522 —— ToolContext 组装(spawner、agentDefinitions、base 由调用方传入)。 */
+export declare function buildRunToolContext(args: {
+    base: ToolContext;
+    options: EngineRunOptions | undefined;
+    configApprovalRouter: ToolContext["approvalRouter"];
+    runPermissionMode: ToolContext["permissionMode"];
+    runPlanMode: boolean;
+    subAgentSpawner: ToolContext["subAgentSpawner"];
+    agentDefinitions: ToolContext["agentDefinitions"];
+    sandbox: ToolContext["sandbox"];
+    cwd: string;
+    shellEnv: ToolContext["shellEnv"];
+    profile: RunBehaviorProfile | undefined;
+    profileParams: Readonly<Record<string, unknown>>;
+    reportResult: (key: string, value: unknown) => void;
+}): ToolContext;
+/** engine.ts L1876-1933 —— 权限分类器 + 审批监听 + ToolExecutor + guards。 */
+export declare function buildRunPermissionPipeline(args: {
+    permissionController: PermissionController;
+    mode: PermissionMode;
+    cwd: string;
+    approvalRouter: ToolContext["approvalRouter"];
+    sessionId: string;
+    toolRegistry: ToolRegistry;
+    hooks: HookRegistry;
+    toolCtx: ToolContext;
+    signal: AbortSignal | undefined;
+    readOnlySession: boolean;
+    headless: boolean;
+    getLatestTodos: () => TaskInfo[];
+    onApprovalPhase: (waiting: boolean, toolName: string | undefined) => void;
+    emitNotificationHook: (payload: Record<string, unknown>) => void;
+}): {
+    permission: PermissionClassifier;
+    toolExecutor: ToolExecutor;
+};
+/** engine.ts L1986-2003 —— MCP 连接(Runtime 池优先,回退 per-Engine)。 */
+export declare function connectRunMcp(args: {
+    mcpServers: Record<string, MCPServerConfig>;
+    mcpDisabled: boolean;
+    getManager: () => MCPManager | undefined;
+    setManager: (manager: MCPManager) => void;
+    runtimePool: MCPManager | undefined;
+    toolRegistry: ToolRegistry;
+    engineForConnect: Parameters<MCPManager["connectAll"]>[1];
+    emitNotificationHook: (payload: Record<string, unknown>) => void;
+}): Promise<void>;
+/**
+ * Inputs to {@link buildToolVisibility}. This is the whole set of run state that
+ * a tool-availability guard is allowed to branch on — naming it keeps the
+ * contract explicit for callers that assemble a tool surface WITHOUT an Engine
+ * run (e.g. a session-scoped host exposing tools to an external Agent Runtime).
+ */
+export interface ToolVisibilityInputs {
+    cwd: string;
+    hasGoal: boolean;
+    sessionId?: string;
+    settingsScope?: SettingsScope;
+    /** Host identity a guard may require, e.g. Panel needs `"desktop"`. */
+    host?: string;
+    isSubAgent?: boolean;
+    behaviorProfile?: string;
+    sessionMessageTargets?: readonly import("../session/session-message.js").SessionMessageTarget[];
+    profileMeta?: Readonly<Record<string, unknown>>;
+}
+/**
+ * Build the availability-guard context for a tool surface.
+ *
+ * Extracted from {@link assembleRunToolDefs} so it is callable on its own. It
+ * matters that this has exactly one implementation: the executor SKIPS its
+ * visibility gate when `toolCtx.toolVisibility` is absent, so a caller that
+ * forgets to populate it doesn't just under-expose tools — it makes host-gated
+ * tools callable in contexts their guards were written to exclude.
+ *
+ * Optional keys are omitted rather than set to `undefined`: guards use
+ * `!== true` / `?? 0` style checks, and an empty `sessionMessageTargets` must not
+ * read as "the host authorized targets".
+ */
+export declare function buildToolVisibility(inputs: ToolVisibilityInputs): import("../tool-system/context.js").ToolVisibilityContext;
+/** engine.ts L2023-2145 —— builtin override / MCP 可见性 / feature flags / 动态 defs / plan-mode 过滤。
+ *  注意:本函数按原逻辑就地 mutate toolCtx(toolVisibility/disabledBuiltins/
+ *  allowedMcpServers/mcpToolPolicies)。 */
+export declare function assembleRunToolDefs(args: {
+    toolRegistry: ToolRegistry;
+    toolCtx: ToolContext;
+    guardCwd: string;
+    hasRunnableGoal: boolean;
+    settingsScope: SettingsScope;
+    builtinToolHost: string | undefined;
+    isSubAgent: boolean;
+    behaviorProfileId: string | undefined;
+    profileMeta: Record<string, unknown> | undefined;
+    builtinOverride: Record<string, CapabilityOverride> | undefined;
+    mcpServers: Record<string, MCPServerConfig>;
+    mcpDisabled: boolean;
+    featureFlags: Parameters<typeof isFeatureEnabled>[0];
+    toolGuards: ReadonlyMap<string, BuiltinToolGuard>;
+    toolRewriters: ReadonlyMap<string, NonNullable<BuiltinToolExposure["rewriteDefinition"]>>;
+    toolFeatureFlags: ReadonlyMap<string, FeatureFlagName>;
+    applyBuiltinOverrideVisibility: <T extends {
+        name: string;
+    }>(tools: T[], override: Record<string, CapabilityOverride> | undefined) => T[];
+    profileAllowedToolNames: ReadonlySet<string> | undefined;
+    runPlanMode: boolean;
+}): ToolDefinition[];