@cjhyy/code-shell-core 0.8.12 → 0.8.20

package/dist/panel-apps/installer.js

@@ -16,6 +16,9 @@ const MAX_FILE_BYTES = 16 * 1024 * 1024;
 const MAX_DEPTH = 16;
 const MAX_MANIFEST_BYTES = 1024 * 1024;
 const MAX_AGENT_SKILL_BYTES = 256 * 1024;
+const MAX_PANEL_DISCOVERY_DEPTH = 4;
+const MAX_PANEL_DISCOVERY_DIRECTORIES = 512;
+const MAX_PANEL_DISCOVERY_RESULTS = 16;
 const REVIEWED_GIT_SNAPSHOT_TTL_MS = 10 * 60 * 1000;
 const MAX_REVIEWED_GIT_SNAPSHOTS = 8;
 const ALLOWED_ASSET_EXTENSIONS = new Set([
@@ -61,9 +64,14 @@ function normalizeGitPanelAppSource(input) {
     if (!raw || raw.length > MAX_SOURCE_PATH || raw.includes("\0")) {
         throw new PanelAppInstallError("GitHub repository URL is invalid");
     }
+    const urlText = /^[A-Za-z0-9_.-]{1,100}\/[A-Za-z0-9_.-]{1,100}(?:\.git)?\/?$/.test(raw)
+        ? `https://github.com/${raw}`
+        : /^github\.com\//i.test(raw)
+            ? `https://${raw}`
+            : raw;
     let parsed;
     try {
-        parsed = new URL(raw);
+        parsed = new URL(urlText);
     }
     catch {
         throw new PanelAppInstallError("GitHub repository URL is invalid");
@@ -135,19 +143,52 @@ function normalizedGitSourceKey(input) {
 function looksLikePanelAppRoot(directory) {
     return existsSync(join(directory, PANEL_APP_MANIFEST_FILE));
 }
+async function discoverPanelAppRoots(directory) {
+    const found = [];
+    const pending = [{ directory, depth: 0 }];
+    let visited = 0;
+    while (pending.length > 0 &&
+        visited < MAX_PANEL_DISCOVERY_DIRECTORIES &&
+        found.length < MAX_PANEL_DISCOVERY_RESULTS) {
+        const current = pending.shift();
+        visited += 1;
+        if (looksLikePanelAppRoot(current.directory)) {
+            found.push(current.directory);
+            continue;
+        }
+        if (current.depth >= MAX_PANEL_DISCOVERY_DEPTH)
+            continue;
+        const entries = await readdir(current.directory, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory() || entry.name.startsWith(".") || entry.name === "node_modules") {
+                continue;
+            }
+            pending.push({ directory: join(current.directory, entry.name), depth: current.depth + 1 });
+        }
+    }
+    return found;
+}
 async function findPanelAppRoot(directory) {
     if (looksLikePanelAppRoot(directory))
         return directory;
-    const entries = await readdir(directory, { withFileTypes: true });
-    const children = entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith("."));
-    if (children.length === 1) {
-        const nested = join(directory, children[0].name);
-        if (looksLikePanelAppRoot(nested))
-            return nested;
-    }
-    throw new PanelAppInstallError(`no Panel App found (expected ${PANEL_APP_MANIFEST_FILE})`);
+    const found = await discoverPanelAppRoots(directory);
+    if (found.length === 1)
+        return found[0];
+    if (found.length > 1) {
+        const candidates = found
+            .map((root) => relative(directory, root).split(sep).join(posix.sep))
+            .sort()
+            .join(", ");
+        throw new PanelAppInstallError(`multiple Panel Apps found; choose an app subdirectory: ${candidates}`);
+    }
+    throw new PanelAppInstallError(`no Panel App found (expected ${PANEL_APP_MANIFEST_FILE}); ` +
+        "for a monorepo, provide the app subdirectory or a GitHub /tree/<ref>/<path> URL");
 }
-async function openGitPanelAppSource(input) {
+function joinedPanelAppSubdirectory(base, nested) {
+    const parts = [base, nested].filter((part) => Boolean(part));
+    return parts.length > 0 ? parts.join("/") : undefined;
+}
+async function openGitPanelAppArchive(input) {
     const source = normalizeGitPanelAppSource(input);
     const temporaryRoot = await mkdtemp(join(tmpdir(), "cs-panel-app-git-"));
     try {
@@ -157,18 +198,86 @@ async function openGitPanelAppSource(input) {
         await downloadGitHubPanelAppArchive(source, archivePath);
         await extractZipSubdirectory(archivePath, extractedRoot, source.subdir);
         await rm(archivePath, { force: true });
+        return { source, extractedRoot, temporaryRoot };
+    }
+    catch (error) {
+        await rm(temporaryRoot, { recursive: true, force: true }).catch(() => undefined);
+        throw error;
+    }
+}
+async function openGitPanelAppSource(input) {
+    const opened = await openGitPanelAppArchive(input);
+    try {
         return {
-            source,
-            sourceKey: JSON.stringify(source),
-            sourceRoot: await findPanelAppRoot(extractedRoot),
-            temporaryRoot,
+            source: opened.source,
+            sourceKey: JSON.stringify(opened.source),
+            sourceRoot: await findPanelAppRoot(opened.extractedRoot),
+            temporaryRoot: opened.temporaryRoot,
         };
     }
     catch (error) {
-        await rm(temporaryRoot, { recursive: true, force: true }).catch(() => undefined);
+        await rm(opened.temporaryRoot, { recursive: true, force: true }).catch(() => undefined);
         throw error;
     }
 }
+/**
+ * Download a public GitHub repository once and enumerate every independently
+ * installable Panel App beneath it. Discovery is read-only: selecting a result
+ * still runs the normal full review and digest-bound install flow.
+ */
+export async function discoverGitPanelApps(input) {
+    const opened = await openGitPanelAppArchive(input);
+    try {
+        const roots = await discoverPanelAppRoots(opened.extractedRoot);
+        if (roots.length === 0) {
+            throw new PanelAppInstallError(`no Panel App found (expected ${PANEL_APP_MANIFEST_FILE}); ` +
+                "check the repository, branch, or optional search subdirectory");
+        }
+        const panels = [];
+        const issues = [];
+        for (const root of roots) {
+            const nested = relative(opened.extractedRoot, root).split(sep).join(posix.sep);
+            const subdir = joinedPanelAppSubdirectory(opened.source.subdir, nested);
+            const label = subdir ?? ".";
+            try {
+                const inspected = await inspectPanelAppSource(root);
+                panels.push({
+                    subdir: label,
+                    source: {
+                        kind: "git",
+                        url: opened.source.url,
+                        ...(opened.source.ref ? { ref: opened.source.ref } : {}),
+                        ...(subdir ? { subdir } : {}),
+                    },
+                    id: inspected.manifest.id,
+                    version: inspected.manifest.version,
+                    title: inspected.manifest.title,
+                    ...(inspected.manifest.description
+                        ? { description: inspected.manifest.description }
+                        : {}),
+                    icon: inspected.manifest.icon,
+                });
+            }
+            catch (error) {
+                issues.push({
+                    subdir: label,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+        panels.sort((left, right) => left.subdir.localeCompare(right.subdir));
+        issues.sort((left, right) => left.subdir.localeCompare(right.subdir));
+        if (panels.length === 0) {
+            throw new PanelAppInstallError(`found ${issues.length} Panel App manifest(s), but none passed validation: ${issues
+                .map((issue) => `${issue.subdir}: ${issue.error}`)
+                .join("; ")}`);
+        }
+        return { source: opened.source, panels, issues };
+    }
+    finally {
+        await rm(opened.temporaryRoot, { recursive: true, force: true }).catch(() => undefined);
+    }
+}
 async function disposeReviewedGitSnapshot(snapshot) {
     clearTimeout(snapshot.expiryTimer);
     await rm(snapshot.temporaryRoot, { recursive: true, force: true }).catch(() => undefined);

package/dist/plugins/pluginCatalog.d.ts

@@ -33,6 +33,12 @@ export interface PluginAutomationTemplateContribution {
  * instantiated later. Install paths and timestamps are intentionally excluded.
  */
 export declare function pluginAutomationTemplateRevision(installKey: string, template: PluginAutomationTemplate): string;
+/**
+ * Read an installed plugin manifest without following links or accepting an
+ * unbounded/non-regular file. Shared by the runtime catalog and UI inventory so
+ * those views cannot disagree about which manifest bytes are trusted.
+ */
+export declare function readCatalogPluginManifest(installPath: string): CanonicalPluginManifestData | null;
 /**
  * Load the installed plugin catalog at the core boundary.
  *

package/dist/plugins/pluginCatalog.js

@@ -19,7 +19,12 @@ export function pluginAutomationTemplateRevision(installKey, template) {
         .update(JSON.stringify(template))
         .digest("hex");
 }
-function readCanonicalManifest(installPath) {
+/**
+ * Read an installed plugin manifest without following links or accepting an
+ * unbounded/non-regular file. Shared by the runtime catalog and UI inventory so
+ * those views cannot disagree about which manifest bytes are trusted.
+ */
+export function readCatalogPluginManifest(installPath) {
     const file = join(installPath, CANONICAL_PLUGIN_MANIFEST_FILE);
     let descriptor;
     try {
@@ -69,7 +74,7 @@ export function loadPluginCatalog(options = {}) {
             const installPath = resolveSafePluginPath(entry.installPath, root);
             if (!installPath)
                 continue;
-            const manifest = readCanonicalManifest(installPath);
+            const manifest = readCatalogPluginManifest(installPath);
             const identity = identityFromInstallKey(installKey, manifest);
             catalog.push({
                 installKey,

package/dist/plugins/pluginContent.d.ts

@@ -7,7 +7,7 @@
  */
 import { type PluginHookEntry } from "./loadPluginHooks.js";
 import { type PluginHookReview } from "./pluginHookApproval.js";
-import { type PluginAutomationTemplate } from "./installer/types.js";
+import type { PluginAutomationTemplate } from "./installer/types.js";
 export type PluginAutomationTemplateDescriptor = PluginAutomationTemplate & {
     revision: string;
 };

package/dist/plugins/pluginContent.js

@@ -11,8 +11,7 @@ import { parseFrontmatter } from "../skills/frontmatter.js";
 import { listPluginHooks } from "./loadPluginHooks.js";
 import { reviewPluginHooks } from "./pluginHookApproval.js";
 import { readPluginMcp } from "./installer/loadPluginMcp.js";
-import { CANONICAL_PLUGIN_MANIFEST_FILE, CanonicalPluginManifest, } from "./installer/types.js";
-import { pluginAutomationTemplateRevision } from "./pluginCatalog.js";
+import { pluginAutomationTemplateRevision, readCatalogPluginManifest } from "./pluginCatalog.js";
 function resolveContainedPath(root, candidate) {
     try {
         const realRoot = realpathSync(root);
@@ -117,14 +116,7 @@ export function describePluginContent(pluginName, installPath, installKey) {
             return undefined;
         }
     })();
-    const manifest = (() => {
-        try {
-            return CanonicalPluginManifest.parse(JSON.parse(readFileSync(join(installPath, CANONICAL_PLUGIN_MANIFEST_FILE), "utf-8")));
-        }
-        catch {
-            return null;
-        }
-    })();
+    const manifest = readCatalogPluginManifest(installPath);
     return {
         skills: listSkills(installPath),
         commands: listMdNames(installPath, "commands"),

package/dist/protocol/chat-session.d.ts

@@ -37,6 +37,8 @@ export interface TurnOpts {
     archiveBeforeCurrentTurn?: {
         fromClientMessageId?: string;
         segmentId?: string;
+        /** Host-authored replacement for the archived span; skips the summarizer. */
+        summary?: string;
     };
     /** Structured input attachments for this turn. */
     attachments?: InputAttachmentMeta[];

package/dist/protocol/server.js

@@ -85,6 +85,13 @@ function runInputError(params) {
                 return `archiveBeforeCurrentTurn.${field} must be a bounded non-empty string`;
             }
         }
+        if (archive.summary !== undefined &&
+            (typeof archive.summary !== "string" ||
+                archive.summary.trim().length === 0 ||
+                archive.summary.length > 4_000 ||
+                /[\u0000]/u.test(archive.summary))) {
+            return "archiveBeforeCurrentTurn.summary must be a non-empty string up to 4000 characters";
+        }
     }
     if (params.behaviorMode !== undefined &&
         (typeof params.behaviorMode !== "string" || params.behaviorMode.length === 0)) {

package/dist/protocol/types.d.ts

@@ -87,6 +87,8 @@ export interface RunParams {
     archiveBeforeCurrentTurn?: {
         fromClientMessageId?: string;
         segmentId?: string;
+        /** Host-authored replacement for the archived span; skips the summarizer. */
+        summary?: string;
     };
     /** Desktop host ownership generation for process-local Quick Chat runs. */
     quickChatClaimId?: string;

package/dist/session/session-manager.d.ts

@@ -221,6 +221,13 @@ export declare class SessionManager {
         state: SessionState;
     } | undefined;
     resume(sessionId: string): SessionBundle;
+    /**
+     * Resume a model run with a bounded active replay for large Pet transcripts
+     * that already contain a full-history archive boundary. Audit/detail callers
+     * continue to use resume() and receive every persisted event.
+     */
+    resumeForRun(sessionId: string): SessionBundle;
+    private resumeWithTranscriptMode;
     /**
      * Return the exact persistence directory owned by this manager.
      *

package/dist/session/session-manager.js

@@ -1001,6 +1001,17 @@ export class SessionManager {
         return undefined;
     }
     resume(sessionId) {
+        return this.resumeWithTranscriptMode(sessionId, false);
+    }
+    /**
+     * Resume a model run with a bounded active replay for large Pet transcripts
+     * that already contain a full-history archive boundary. Audit/detail callers
+     * continue to use resume() and receive every persisted event.
+     */
+    resumeForRun(sessionId) {
+        return this.resumeWithTranscriptMode(sessionId, true);
+    }
+    resumeWithTranscriptMode(sessionId, contextOnly) {
         assertSafeSessionId(sessionId);
         const processLocal = this.processLocalBundle(sessionId);
         if (processLocal) {
@@ -1037,8 +1048,10 @@ export class SessionManager {
             chmodSync(sessionDir, 0o700);
             chmodSync(stateFile, 0o600);
         }
-        const transcript = Transcript.loadFromFile(transcriptFile);
         state.kind = normalizedSessionKind(state.kind);
+        const transcript = contextOnly && state.kind === "pet"
+            ? Transcript.loadContextFromFile(transcriptFile)
+            : Transcript.loadFromFile(transcriptFile);
         state.status = "active";
         delete state.lastCompletionKind;
         Object.assign(state, normalizeCumulativeUsageCounters(state, state.tokenUsage));
@@ -1697,11 +1710,11 @@ export class SessionManager {
     list(limit = 20, opts) {
         if (!existsSync(this.sessionsDir))
             return [];
-        // Extension-owned session kinds stay out of generic lists. Defaults to
-        // hiding "pet" so default-arg callers keep today's behavior.
-        // TODO(pet-out-of-core): drop the default once every caller passes the
-        // host's hidden-kind union explicitly.
-        const excludeKinds = opts?.excludeKinds ?? ["pet"];
+        // Core is domain-agnostic: only the composition root knows which
+        // extension-owned kinds belong outside its generic list. AgentServer passes
+        // the resolved hidden-kind union explicitly; direct SDK callers see every
+        // kind unless they choose exclusions themselves.
+        const excludeKinds = opts?.excludeKinds ?? [];
         const dirs = readdirSync(this.sessionsDir, { withFileTypes: true })
             .filter((d) => d.isDirectory() && !d.name.startsWith(".pending-") && !d.name.startsWith("qchat-"))
             .map((d) => d.name);

package/dist/session/transcript.d.ts

@@ -184,6 +184,15 @@ export declare class Transcript {
      */
     static selectContextRange(events: readonly TranscriptEvent[], range: ContextEventRange): SelectedContextRange;
     static loadFromFile(filePath: string): Transcript;
+    /**
+     * Load the active replay for a model run while leaving the append-only audit
+     * transcript untouched on disk. A host-authored from-less range archive
+     * replaces everything before its `to` anchor, so a large Mimi transcript can
+     * retain only that boundary and the live tail in memory. If the boundary is
+     * absent, too old, malformed, or not self-contained in the bounded tail, we
+     * fail open to the full loader.
+     */
+    static loadContextFromFile(filePath: string, maxTailBytes?: number): Transcript;
     private loadEvents;
 }
 export {};

package/dist/session/transcript.js

@@ -6,6 +6,7 @@ import { appendFileSync, chmodSync, closeSync, existsSync, fchmodSync, fstatSync
 import { dirname } from "node:path";
 import { nanoid } from "nanoid";
 import { logger } from "../logging/logger.js";
+const DEFAULT_CONTEXT_TAIL_SCAN_BYTES = 32 * 1024 * 1024;
 function appendTranscriptLine(filePath, data) {
     // Use one append-mode descriptor so concurrent OS writers cannot overwrite
     // one another. Also repair the record boundary after a crash-torn final line;
@@ -678,6 +679,86 @@ export class Transcript {
         transcript.repairToolResultPairs();
         return transcript;
     }
+    /**
+     * Load the active replay for a model run while leaving the append-only audit
+     * transcript untouched on disk. A host-authored from-less range archive
+     * replaces everything before its `to` anchor, so a large Mimi transcript can
+     * retain only that boundary and the live tail in memory. If the boundary is
+     * absent, too old, malformed, or not self-contained in the bounded tail, we
+     * fail open to the full loader.
+     */
+    static loadContextFromFile(filePath, maxTailBytes = DEFAULT_CONTEXT_TAIL_SCAN_BYTES) {
+        if (!existsSync(filePath))
+            return new Transcript(filePath);
+        let tail;
+        try {
+            const fd = openSync(filePath, "r");
+            try {
+                const fileSize = fstatSync(fd).size;
+                if (fileSize <= maxTailBytes)
+                    return Transcript.loadFromFile(filePath);
+                const length = Math.min(fileSize, Math.max(1, maxTailBytes));
+                const buffer = Buffer.allocUnsafe(length);
+                const bytesRead = readSync(fd, buffer, 0, length, fileSize - length);
+                let window = buffer.subarray(0, bytesRead);
+                const newline = window.indexOf(0x0a);
+                if (newline < 0)
+                    return Transcript.loadFromFile(filePath);
+                window = window.subarray(newline + 1);
+                tail = window.toString("utf8");
+            }
+            finally {
+                closeSync(fd);
+            }
+        }
+        catch {
+            return Transcript.loadFromFile(filePath);
+        }
+        const events = [];
+        for (const line of tail.split("\n")) {
+            if (!line.trim())
+                continue;
+            try {
+                events.push(JSON.parse(line));
+            }
+            catch {
+                // A malformed tail must not turn a partial window into authoritative
+                // context. The normal loader keeps its established skip behavior.
+                return Transcript.loadFromFile(filePath);
+            }
+        }
+        let markerIndex = -1;
+        let toClientMessageId;
+        for (const [index, event] of events.entries()) {
+            if (event.type !== "range_archive")
+                continue;
+            const data = event.data;
+            if (data.fromClientMessageId === undefined &&
+                typeof data.summary === "string" &&
+                typeof data.toClientMessageId === "string") {
+                markerIndex = index;
+                toClientMessageId = data.toClientMessageId;
+            }
+        }
+        if (markerIndex < 0 || !toClientMessageId)
+            return Transcript.loadFromFile(filePath);
+        const anchorIndex = events.findIndex((event, index) => index < markerIndex &&
+            event.type === "message" &&
+            event.data.clientMessageId === toClientMessageId);
+        if (anchorIndex < 0)
+            return Transcript.loadFromFile(filePath);
+        let startIndex = anchorIndex;
+        for (let index = anchorIndex - 1; index >= 0; index -= 1) {
+            if (events[index]?.type !== "turn_boundary")
+                continue;
+            startIndex = index;
+            break;
+        }
+        const transcript = new Transcript(filePath);
+        transcript.loadEvents(events.slice(startIndex));
+        transcript.repairToolResultPairs();
+        return transcript;
+    }
     loadEvents(events) {
         this.events = structuredClone([...events]);
         this.currentTurn = 0;

package/dist/settings/manager.d.ts

@@ -153,6 +153,18 @@ export declare class SettingsManager {
      * be shared with collaborators.
      */
     saveLocalSetting(key: string, value: unknown, cwd: string): void;
+    /**
+     * Mutate one writable settings layer under the same cross-process lock used
+     * by the desktop settings service. Domain tools use this when two related
+     * fields must change atomically (for example modelConnections + defaults):
+     * composing multiple save*Setting calls would expose an intermediate state
+     * and could interleave with another process between writes.
+     *
+     * The callback receives only the selected layer's raw object, not the merged
+     * settings view. The result is schema-validated before it replaces the file.
+     * Returning false makes the operation a no-op.
+     */
+    mutateSettingsForScope(scope: "user" | "project", cwd: string, mutate: (current: Record<string, unknown>) => boolean | void): void;
     /**
      * Delete a single dotted key from the PROJECT-level config file. Used to
      * express "inherit" — we don't persist the literal "inherit"; we remove the

package/dist/settings/manager.js

@@ -417,6 +417,37 @@ export class SettingsManager {
         });
         this.invalidate();
     }
+    /**
+     * Mutate one writable settings layer under the same cross-process lock used
+     * by the desktop settings service. Domain tools use this when two related
+     * fields must change atomically (for example modelConnections + defaults):
+     * composing multiple save*Setting calls would expose an intermediate state
+     * and could interleave with another process between writes.
+     *
+     * The callback receives only the selected layer's raw object, not the merged
+     * settings view. The result is schema-validated before it replaces the file.
+     * Returning false makes the operation a no-op.
+     */
+    mutateSettingsForScope(scope, cwd, mutate) {
+        const path = scope === "user"
+            ? join(this.userConfigDir(), "settings.json")
+            : this.projectSettingsPath(cwd);
+        if (scope === "project") {
+            this.validateProjectCwd(cwd, "project");
+            if (!existsSync(cwd))
+                throw new Error(`project directory does not exist: ${cwd}`);
+        }
+        this.mutateSettingsFile(path, (current) => {
+            if (mutate(current) === false)
+                return false;
+            // Validate the complete resulting layer before persistence. We keep the
+            // original object for serialization so forward-compatible unknown keys
+            // are preserved instead of being stripped by Zod's parsed result.
+            validateSettings(current);
+            return true;
+        });
+        this.invalidate();
+    }
     /**
      * Delete a single dotted key from the PROJECT-level config file. Used to
      * express "inherit" — we don't persist the literal "inherit"; we remove the

package/dist/tool-system/builtin/configure-model-connection.d.ts

@@ -0,0 +1,36 @@
+/**
+ * ConfigureModelConnection — safely materialize one catalog model into the
+ * unified settings.modelConnections store without exposing or copying API
+ * keys. The write is schema-validated, lock-protected, atomic, and updates the
+ * selected tag default in the same transaction when requested.
+ */
+import type { ToolDefinition } from "../../types.js";
+import type { ToolContext } from "../context.js";
+import { SettingsManager } from "../../settings/manager.js";
+import { type CatalogEntry } from "../../model-catalog/index.js";
+import { createLLMClient } from "../../llm/client-factory.js";
+import { type Credential, type ModelInstance } from "../../model-catalog/resolve.js";
+interface ConfigureModelConnectionDeps {
+    makeSettingsManager(cwd: string, scope: "full" | "project"): SettingsManager;
+    getCatalog(): CatalogEntry[];
+    notifySettingsChanged(): void;
+    testTextConnection(connection: ModelInstance, credentials: Credential[], catalog: CatalogEntry[]): Promise<ConnectionTestResult>;
+}
+interface ConnectionTestResult {
+    ok: boolean;
+    response?: string;
+    stopReason?: string;
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+    error?: string;
+}
+export declare function probeTextModelConnection(connection: ModelInstance, credentials: Credential[], catalog: CatalogEntry[], options?: {
+    fetch?: typeof globalThis.fetch;
+    createClient?: typeof createLLMClient;
+}): Promise<ConnectionTestResult>;
+export declare const configureModelConnectionToolDef: ToolDefinition;
+export declare function configureModelConnectionTool(args: Record<string, unknown>, ctx?: ToolContext, deps?: ConfigureModelConnectionDeps): Promise<string>;
+export {};