@cjhyy/code-shell-server 0.9.8 → 0.9.9

package/dist/panels/agent-task-service.js

@@ -0,0 +1,283 @@
+import { randomUUID } from "node:crypto";
+const MAX_TASKS = 200;
+const MAX_PROMPT_CHARS = 20_000;
+const MAX_RESULT_CHARS = 64_000;
+const MAX_ACTIVITY_ITEMS = 40;
+const MAX_ACTIVITY_MESSAGE_CHARS = 500;
+const TERMINAL_STATUSES = new Set(["completed", "failed", "cancelled"]);
+const TOOL_NAME = /^[A-Za-z][A-Za-z0-9_.:-]{0,127}$/;
+const TASK_KEY = /^[a-z][a-z0-9_-]{0,63}$/;
+function cleanError(error) {
+    return (error instanceof Error ? error.message : String(error || "Task failed")).slice(0, 1_000);
+}
+function failureForReason(reason) {
+    switch (reason) {
+        case "model_error":
+            return "The AI model request failed. Check the selected model and its API credentials.";
+        case "prompt_too_long":
+            return "The Task prompt exceeded the model context limit.";
+        case "max_turns":
+            return "The Task reached its turn limit before finishing.";
+        case "goal_budget_exhausted":
+            return "The Task reached its configured budget before finishing.";
+        case "aborted_streaming":
+        case "aborted_tools":
+            return "The Task was interrupted before finishing.";
+        default:
+            return reason ? `The Task ended before completion (${reason}).` : "Task failed";
+    }
+}
+function publicTask(task) {
+    return {
+        id: task.id,
+        ...(task.key ? { key: task.key } : {}),
+        label: task.label,
+        status: task.status,
+        ...(task.model ? { model: task.model } : {}),
+        ...(task.skill ? { skill: task.skill } : {}),
+        createdAt: task.createdAt,
+        updatedAt: task.updatedAt,
+        ...(task.completedAt ? { completedAt: task.completedAt } : {}),
+        ...(task.result ? { result: structuredClone(task.result) } : {}),
+        ...(task.error ? { error: task.error } : {}),
+        ...(task.activity?.length ? { activity: structuredClone(task.activity) } : {}),
+    };
+}
+function sameScope(task, owner) {
+    return task.owner.appId === owner.appId && task.owner.projectPath === owner.projectPath;
+}
+export class PanelAppAgentTaskService {
+    runtime;
+    emitChanged;
+    now;
+    makeId;
+    tasks = new Map();
+    constructor(runtime, emitChanged, now = Date.now, makeId = randomUUID) {
+        this.runtime = runtime;
+        this.emitChanged = emitChanged;
+        this.now = now;
+        this.makeId = makeId;
+    }
+    start(owner, raw) {
+        const prompt = typeof raw.prompt === "string" ? raw.prompt.trim() : "";
+        if (!prompt || prompt.length > MAX_PROMPT_CHARS) {
+            throw new Error("agent.task.start requires a non-empty prompt up to 20000 characters");
+        }
+        const label = typeof raw.label === "string" ? raw.label.trim() : "";
+        if (!label || label.length > 200) {
+            throw new Error("agent.task.start requires a non-empty label up to 200 characters");
+        }
+        const key = raw.key === undefined ? undefined : String(raw.key);
+        if (key !== undefined && !TASK_KEY.test(key)) {
+            throw new Error("agent.task.start key must match ^[a-z][a-z0-9_-]{0,63}$");
+        }
+        const model = raw.model === undefined ? undefined : String(raw.model).trim();
+        if (model !== undefined && (!model || model.length > 256 || /[\r\n\0]/.test(model))) {
+            throw new Error("agent.task.start model must be a bounded non-empty connection id");
+        }
+        const skill = raw.skill === undefined ? undefined : String(raw.skill);
+        if (skill !== undefined && !owner.availableSkills.includes(skill)) {
+            throw new Error(`Task Skill '${skill}' is not bundled with this Panel App`);
+        }
+        const requestedSkills = raw.skills === undefined ? [] : raw.skills;
+        if (!Array.isArray(requestedSkills) ||
+            requestedSkills.length > 8 ||
+            requestedSkills.some((name) => typeof name !== "string" || !owner.availableSkills.includes(name)))
+            throw new Error("Task Skills must be bundled with this Panel App (at most 8)");
+        const skillNames = [...new Set([...(skill ? [skill] : []), ...requestedSkills])];
+        const requestedTools = raw.toolNames === undefined ? [] : raw.toolNames;
+        if (!Array.isArray(requestedTools) ||
+            requestedTools.length > 32 ||
+            requestedTools.some((name) => typeof name !== "string" || !TOOL_NAME.test(name))) {
+            throw new Error("agent.task.start toolNames must contain at most 32 valid tool names");
+        }
+        const maxTurns = raw.maxTurns === undefined ? 8 : Number(raw.maxTurns);
+        if (!Number.isInteger(maxTurns) || maxTurns < 1 || maxTurns > 20) {
+            throw new Error("agent.task.start maxTurns must be an integer from 1 to 20");
+        }
+        const maxContextTokens = raw.maxContextTokens === undefined ? 32_768 : Number(raw.maxContextTokens);
+        if (!Number.isInteger(maxContextTokens) ||
+            maxContextTokens < 4_096 ||
+            maxContextTokens > 65_536) {
+            throw new Error("agent.task.start maxContextTokens must be from 4096 to 65536");
+        }
+        if (key) {
+            const existing = [...this.tasks.values()].find((task) => sameScope(task, owner) && task.key === key && !TERMINAL_STATUSES.has(task.status));
+            if (existing)
+                return publicTask(existing);
+        }
+        const createdAt = this.now();
+        const id = `task-${this.makeId()}`;
+        const toolNames = [...new Set(requestedTools)];
+        if (skillNames.length && !toolNames.includes("Skill"))
+            toolNames.push("Skill");
+        const task = {
+            id,
+            ...(key ? { key } : {}),
+            label,
+            status: "queued",
+            ...(model ? { model } : {}),
+            ...(skill ? { skill } : {}),
+            createdAt,
+            updatedAt: createdAt,
+            sessionId: `panel-task-${this.makeId()}`,
+            owner: { ...owner, availableSkills: [...owner.availableSkills] },
+            prompt,
+            toolNames,
+            skillNames,
+            maxTurns,
+            maxContextTokens,
+            cancelRequested: false,
+            activity: [],
+        };
+        this.tasks.set(task.id, task);
+        this.trimHistory();
+        this.emit(task);
+        void this.execute(task);
+        return publicTask(task);
+    }
+    list(owner) {
+        return [...this.tasks.values()]
+            .filter((task) => sameScope(task, owner))
+            .sort((a, b) => b.createdAt - a.createdAt)
+            .map(publicTask);
+    }
+    get(owner, id) {
+        const task = this.scopedTask(owner, id);
+        return publicTask(task);
+    }
+    async cancel(owner, id) {
+        const task = this.scopedTask(owner, id);
+        if (TERMINAL_STATUSES.has(task.status))
+            return publicTask(task);
+        task.cancelRequested = true;
+        task.status = "cancelling";
+        task.updatedAt = this.now();
+        this.emit(task);
+        try {
+            await this.runtime.cancel(task.sessionId);
+        }
+        catch (error) {
+            task.error = cleanError(error);
+            task.updatedAt = this.now();
+            this.emit(task);
+        }
+        return publicTask(task);
+    }
+    rebind(owner) {
+        for (const task of this.tasks.values()) {
+            if (!sameScope(task, owner) || TERMINAL_STATUSES.has(task.status))
+                continue;
+            task.owner = { ...owner, availableSkills: [...owner.availableSkills] };
+            this.runtime.rebind(task.sessionId, task.owner);
+        }
+    }
+    cancelApp(appId) {
+        for (const task of this.tasks.values()) {
+            if (task.owner.appId !== appId || TERMINAL_STATUSES.has(task.status))
+                continue;
+            task.cancelRequested = true;
+            task.status = "cancelling";
+            task.updatedAt = this.now();
+            this.emit(task);
+            void this.runtime.cancel(task.sessionId).catch(() => undefined);
+        }
+    }
+    async execute(task) {
+        task.status = "running";
+        task.updatedAt = this.now();
+        this.emit(task);
+        try {
+            const result = await this.runtime.run({
+                taskId: task.id,
+                sessionId: task.sessionId,
+                owner: task.owner,
+                prompt: task.prompt,
+                label: task.label,
+                ...(task.model ? { model: task.model } : {}),
+                toolNames: task.toolNames,
+                skillNames: task.skillNames,
+                maxTurns: task.maxTurns,
+                maxContextTokens: task.maxContextTokens,
+                onProgress: (progress) => this.recordProgress(task, progress),
+            });
+            task.result = {
+                text: String(result.text || "").slice(0, MAX_RESULT_CHARS),
+                ...(result.reason ? { reason: result.reason } : {}),
+                ...(result.usage ? { usage: result.usage } : {}),
+            };
+            if (task.cancelRequested) {
+                task.status = "cancelled";
+            }
+            else if (result.reason && result.reason !== "completed") {
+                task.status = "failed";
+                task.error = cleanError(result.error || result.text || failureForReason(result.reason));
+            }
+            else {
+                task.status = "completed";
+            }
+        }
+        catch (error) {
+            task.status = task.cancelRequested ? "cancelled" : "failed";
+            task.error = cleanError(error);
+        }
+        finally {
+            task.updatedAt = this.now();
+            task.completedAt = task.updatedAt;
+            this.emit(task);
+            await this.runtime.close(task.sessionId).catch(() => undefined);
+        }
+    }
+    scopedTask(owner, id) {
+        if (typeof id !== "string" || !id)
+            throw new Error("agent.task requires a task id");
+        const task = this.tasks.get(id);
+        if (!task || !sameScope(task, owner))
+            throw new Error("Task not found for this Panel App");
+        return task;
+    }
+    emit(task) {
+        this.emitChanged(task.owner, publicTask(task));
+    }
+    recordProgress(task, progress) {
+        if (TERMINAL_STATUSES.has(task.status))
+            return;
+        const message = String(progress.message || "")
+            .trim()
+            .slice(0, MAX_ACTIVITY_MESSAGE_CHARS);
+        if (!message)
+            return;
+        const toolName = progress.toolName?.trim().slice(0, 128);
+        const previous = task.activity?.at(-1);
+        if (previous?.kind === progress.kind &&
+            previous.status === progress.status &&
+            previous.message === message &&
+            previous.toolName === toolName) {
+            return;
+        }
+        task.activity ??= [];
+        task.activity.push({
+            kind: progress.kind,
+            status: progress.status,
+            message,
+            ...(toolName ? { toolName } : {}),
+            at: this.now(),
+        });
+        if (task.activity.length > MAX_ACTIVITY_ITEMS) {
+            task.activity.splice(0, task.activity.length - MAX_ACTIVITY_ITEMS);
+        }
+        task.updatedAt = this.now();
+        this.emit(task);
+    }
+    trimHistory() {
+        if (this.tasks.size <= MAX_TASKS)
+            return;
+        for (const task of this.tasks.values()) {
+            if (!TERMINAL_STATUSES.has(task.status))
+                continue;
+            this.tasks.delete(task.id);
+            if (this.tasks.size <= MAX_TASKS)
+                return;
+        }
+    }
+}

package/dist/panels/http.d.ts

@@ -0,0 +1,34 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { type PanelManagementHttpOptions } from "./management-http.js";
+import { type PanelAgentTaskHostOptions } from "./agent-task-host.js";
+export declare function createPanelHttp(options: PanelManagementHttpOptions & {
+    dataDir: string;
+    host: "hub" | "desktop";
+    publicPathPrefix?: string;
+    agentTaskOptions?: PanelAgentTaskHostOptions;
+}): {
+    service: {
+        snapshot: () => Promise<import("./types.js").PanelSnapshot>;
+        assertAuthorized: (context: import("./types.js").PanelOperationContext, expected?: number) => Promise<void>;
+        discover(context: import("./types.js").PanelOperationContext, input: unknown): Promise<import("./types.js").PanelDiscovery>;
+        preview: (context: import("./types.js").PanelOperationContext, input: unknown) => Promise<import("./types.js").PanelReview>;
+        previewUpdate(context: import("./types.js").PanelOperationContext, id: unknown, expected: unknown): Promise<import("./types.js").PanelReview>;
+        install(context: import("./types.js").PanelOperationContext, token: unknown, bind?: boolean): Promise<{
+            id: string;
+        }>;
+        binding(context: import("./types.js").PanelOperationContext, id: unknown, bound: unknown, expected: unknown): Promise<import("./types.js").PanelSnapshot>;
+        remove(context: import("./types.js").PanelOperationContext, id: unknown, expected: unknown): Promise<{
+            removed: true;
+        }>;
+        cancelOwner(owner: string): void;
+        close(): void;
+    };
+    activeTaskCount: () => number;
+    panelAction: (ownerId: string, sessionId: string, input: Record<string, unknown>) => Promise<unknown>;
+    invalidate: (appId?: string) => void;
+    ownsAssets: (request: IncomingMessage) => boolean;
+    handleAssets: (request: IncomingMessage, response: ServerResponse) => Promise<boolean>;
+    handle(request: IncomingMessage, response: ServerResponse): Promise<boolean>;
+    cancelOwner(owner: string): void;
+    close(): void;
+};

package/dist/panels/http.js

@@ -0,0 +1,37 @@
+import { createPanelManagementHttp } from "./management-http.js";
+import { createPanelRuntime, panelWebCompatibility } from "./runtime.js";
+import { createPanelAgentTaskHost } from "./agent-task-host.js";
+export function createPanelHttp(options) {
+    const management = createPanelManagementHttp({
+        ...options,
+        compatibility: options.compatibility ?? panelWebCompatibility,
+        onChanged: async (id, kind) => {
+            runtime?.invalidate(id);
+            await options.onChanged?.(id, kind);
+        },
+    });
+    const runtime = createPanelRuntime({
+        ...options,
+        snapshot: management.service.snapshot,
+        createAgentTasks: (hooks) => createPanelAgentTaskHost({ ...options.agentTaskOptions, ...hooks }),
+    });
+    return {
+        service: management.service,
+        activeTaskCount: runtime.activeTaskCount,
+        panelAction: runtime.panelAction,
+        invalidate: runtime.invalidate,
+        ownsAssets: runtime.ownsAssets,
+        handleAssets: runtime.handleAssets,
+        async handle(request, response) {
+            return (await runtime.handle(request, response)) || management.handle(request, response);
+        },
+        cancelOwner(owner) {
+            runtime.cancelOwner(owner);
+            management.cancelOwner(owner);
+        },
+        close() {
+            runtime.close();
+            management.close();
+        },
+    };
+}

package/dist/panels/hub-binding.d.ts

@@ -0,0 +1,12 @@
+export interface HubPanelBinding {
+    bindingCwd: string;
+    /** Cheap synchronous topology check; never derives a new target after startup. */
+    assertBinding: () => void;
+}
+/**
+ * --cwd authorizes that workspace, not an arbitrary path written into .git.
+ * Verify Git's forward and reverse worktree relationship once, then freeze the
+ * binding target shared by management, storage, and Core's Skill scanner.
+ * An unsupported or changed topology disables panels without stopping the Hub.
+ */
+export declare function createHubPanelBinding(cwdInput: string): HubPanelBinding;

package/dist/panels/hub-binding.js

@@ -0,0 +1,174 @@
+import { execFileSync } from "node:child_process";
+import { constants, closeSync, fstatSync, lstatSync, openSync, readFileSync, realpathSync, } from "node:fs";
+import { devNull } from "node:os";
+import { basename, dirname, join, resolve, sep } from "node:path";
+import { resolvePanelAppBindingProjectPath } from "@cjhyy/code-shell-core";
+import { PanelManagementError } from "./management.js";
+function refused() {
+    throw new PanelManagementError(403, "panel_binding_unavailable", "无法核验面板所属项目，或 Git 工作区关联已经变化。请检查工作区后重启服务，再绑定面板。");
+}
+function metadata(file) {
+    try {
+        return lstatSync(file);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return;
+        throw error;
+    }
+}
+function readPointer(file) {
+    const descriptor = openSync(file, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0));
+    try {
+        const info = fstatSync(descriptor);
+        if (!info.isFile() || info.size > 8192)
+            refused();
+        const content = readFileSync(descriptor, "utf8");
+        if (Buffer.byteLength(content) > 8192 || content.includes("\0"))
+            refused();
+        return { content, identity: `${info.dev}:${info.ino}` };
+    }
+    finally {
+        closeSync(descriptor);
+    }
+}
+function nearestGit(cwd) {
+    let current = cwd;
+    for (let depth = 0; depth < 256; depth++) {
+        const path = join(current, ".git");
+        const info = metadata(path);
+        if (info) {
+            if (info.isSymbolicLink() || (!info.isDirectory() && !info.isFile()))
+                refused();
+            return { root: current, path, info };
+        }
+        const parent = dirname(current);
+        if (parent === current)
+            return;
+        current = parent;
+    }
+    return refused();
+}
+function sameIdentity(actual, expected) {
+    return actual.dev === expected.dev && actual.ino === expected.ino;
+}
+function directoryGuard(path) {
+    const canonical = realpathSync(path);
+    const info = lstatSync(canonical);
+    if (!info.isDirectory() || info.isSymbolicLink())
+        refused();
+    return () => {
+        if (realpathSync(path) !== canonical)
+            refused();
+        const current = lstatSync(canonical);
+        if (!current.isDirectory() || current.isSymbolicLink() || !sameIdentity(current, info))
+            refused();
+    };
+}
+function pointerGuard(path) {
+    const initial = readPointer(path);
+    return () => {
+        const current = readPointer(path);
+        if (current.content !== initial.content || current.identity !== initial.identity)
+            refused();
+    };
+}
+/**
+ * --cwd authorizes that workspace, not an arbitrary path written into .git.
+ * Verify Git's forward and reverse worktree relationship once, then freeze the
+ * binding target shared by management, storage, and Core's Skill scanner.
+ * An unsupported or changed topology disables panels without stopping the Hub.
+ */
+export function createHubPanelBinding(cwdInput) {
+    const cwd = resolve(cwdInput);
+    try {
+        const guards = [directoryGuard(cwd)];
+        const initial = nearestGit(cwd);
+        let bindingCwd = cwd;
+        if (initial) {
+            const environment = { ...process.env };
+            for (const key of Object.keys(environment))
+                if (key.startsWith("GIT_"))
+                    delete environment[key];
+            environment.GIT_CONFIG_NOSYSTEM = "1";
+            environment.GIT_CONFIG_GLOBAL = devNull;
+            environment.GIT_OPTIONAL_LOCKS = "0";
+            const git = (at, ...args) => execFileSync("git", ["-c", "core.fsmonitor=false", "-C", at, ...args], {
+                env: environment,
+                encoding: "utf8",
+                timeout: 3000,
+                maxBuffer: 256 * 1024,
+                stdio: ["ignore", "pipe", "pipe"],
+            }).trimEnd();
+            const top = realpathSync(git(cwd, "rev-parse", "--show-toplevel"));
+            const gitDir = realpathSync(git(cwd, "rev-parse", "--absolute-git-dir"));
+            const common = realpathSync(resolve(cwd, git(cwd, "rev-parse", "--git-common-dir")));
+            if (top !== realpathSync(initial.root))
+                refused();
+            bindingCwd = resolvePanelAppBindingProjectPath(cwd);
+            guards.push(directoryGuard(initial.root), directoryGuard(common));
+            if (initial.info.isDirectory()) {
+                if (gitDir !== realpathSync(initial.path) ||
+                    common !== gitDir ||
+                    realpathSync(bindingCwd) !== top)
+                    refused();
+                guards.push(directoryGuard(initial.path));
+            }
+            else {
+                // Standard linked worktrees must point into the main repository's own
+                // registry, whose back-pointer names this exact .git file.
+                if (basename(common) !== ".git")
+                    refused();
+                const main = dirname(common);
+                const relativeGitDir = gitDir.slice(common.length + 1);
+                if (!gitDir.startsWith(common + sep) ||
+                    !/^worktrees[\\/][^\\/]+$/.test(relativeGitDir) ||
+                    realpathSync(bindingCwd) !== realpathSync(main))
+                    refused();
+                if (realpathSync(git(main, "rev-parse", "--show-toplevel")) !== realpathSync(main))
+                    refused();
+                if (realpathSync(git(main, "rev-parse", "--absolute-git-dir")) !== common)
+                    refused();
+                const backPointer = join(gitDir, "gitdir");
+                const commonPointer = join(gitDir, "commondir");
+                if (realpathSync(readPointer(backPointer).content.trim()) !== realpathSync(initial.path))
+                    refused();
+                if (realpathSync(resolve(gitDir, readPointer(commonPointer).content.trim())) !== common)
+                    refused();
+                const listed = git(main, "worktree", "list", "--porcelain", "-z")
+                    .split("\0")
+                    .filter((line) => line.startsWith("worktree "))
+                    .map((line) => line.slice(9));
+                if (!listed.includes(top) || !listed.includes(realpathSync(main)))
+                    refused();
+                guards.push(directoryGuard(main), directoryGuard(gitDir), pointerGuard(initial.path), pointerGuard(backPointer), pointerGuard(commonPointer));
+            }
+        }
+        const frozen = bindingCwd;
+        const assertBinding = () => {
+            try {
+                for (const check of guards)
+                    check();
+                const current = nearestGit(cwd);
+                if (initial) {
+                    if (!current ||
+                        current.path !== initial.path ||
+                        !sameIdentity(current.info, initial.info))
+                        refused();
+                }
+                else if (current && (current.root !== cwd || !current.info.isDirectory()))
+                    refused();
+                if (resolvePanelAppBindingProjectPath(cwd) !== frozen)
+                    refused();
+            }
+            catch {
+                refused();
+            }
+        };
+        assertBinding();
+        return { bindingCwd: frozen, assertBinding };
+    }
+    catch {
+        return { bindingCwd: cwd, assertBinding: refused };
+    }
+}

package/dist/panels/management-http.d.ts

@@ -0,0 +1,29 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { type PanelManagementOptions } from "./management.js";
+import type { PanelOperationContext } from "./types.js";
+export interface PanelManagementHttpOptions extends PanelManagementOptions {
+    ownerId: (request: IncomingMessage) => Promise<string | undefined>;
+    isAuthorized: (request: IncomingMessage) => Promise<boolean>;
+}
+/** Call only after the host's same-origin authentication boundary. */
+export declare function createPanelManagementHttp(options: PanelManagementHttpOptions): {
+    service: {
+        snapshot: () => Promise<import("./types.js").PanelSnapshot>;
+        assertAuthorized: (context: PanelOperationContext, expected?: number) => Promise<void>;
+        discover(context: PanelOperationContext, input: unknown): Promise<import("./types.js").PanelDiscovery>;
+        preview: (context: PanelOperationContext, input: unknown) => Promise<import("./types.js").PanelReview>;
+        previewUpdate(context: PanelOperationContext, id: unknown, expected: unknown): Promise<import("./types.js").PanelReview>;
+        install(context: PanelOperationContext, token: unknown, bind?: boolean): Promise<{
+            id: string;
+        }>;
+        binding(context: PanelOperationContext, id: unknown, bound: unknown, expected: unknown): Promise<import("./types.js").PanelSnapshot>;
+        remove(context: PanelOperationContext, id: unknown, expected: unknown): Promise<{
+            removed: true;
+        }>;
+        cancelOwner(owner: string): void;
+        close(): void;
+    };
+    close: () => void;
+    cancelOwner: (owner: string) => void;
+    handle(request: IncomingMessage, response: ServerResponse): Promise<boolean>;
+};