@cjhyy/code-shell-host 0.0.0-stage → 0.9.44

package/README.md

@@ -1,3 +1,26 @@
-# Temporary Holding Version
+# CodeShell Host
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Minimal HostRuntime foundation shared by Desktop, serve and Panel task workers.
+Depends only on Core. The registry owns capability declarations, legacy worker
+request classification and dispatch, and synchronous adapter/service lifecycle.
+Adapters supply platform handlers; no Electron, transport or coding pack is loaded.
+
+`interceptHostRequest` consumes unsupported worker requests before client routing.
+Supported handlers keep their existing wire format. Ordinary approvals keep the
+host client approval path; AskUser requires a real text-answer UI. Desktop/Web
+retain that path, while Panel task hosts immediately return a typed `unavailable`
+decision with an explicit unsupported reason. They never turn a yes/no confirmation
+into a user answer; Core retires asynchronous questions without injecting an answer
+or starting a follow-up run. This package does not implement
+Protocol v2, credential storage, automation scheduling or the later service moves.
+
+Desktop bundles this package into its main process, so its dependency belongs in
+Desktop `devDependencies`. The production workspace materialization list used by
+`predist` also drives the packaging guard; bundled Host is not copied as a runtime
+workspace symlink.
+
+Panel workers use `CODE_SHELL_CREDENTIAL_ACCESS=local`: they read Core's local
+credential store, not Desktop's credential IPC/safeStorage service. Foreign
+safeStorage ciphertext fails closed; supported plaintext tags and legacy bare
+plaintext remain readable under the existing local store rules. This is not
+credential-service parity or a separate per-task vault.

package/dist/host-requests.d.ts

@@ -0,0 +1,49 @@
+import type { HostRuntime } from "./runtime.js";
+export interface ServeHostCapabilities {
+    panels: boolean;
+}
+/** Compatibility surface for S0 callers. */
+export declare function unsupportedLoopbackCapability(toolName: unknown, host: ServeHostCapabilities): string | undefined;
+export declare function unsupportedLoopbackAnswer(capability: string, hostLabel?: string): string;
+/** AskUser expects human text, so an unsupported host must never approve a synthetic answer. */
+export declare function unsupportedAskUserDecision(hostLabel: string): {
+    approved: false;
+    failure: "unavailable";
+    reason: string;
+};
+export declare function isHostAuthorityRequest(message: {
+    id?: unknown;
+    method?: unknown;
+}): message is {
+    id: string | number;
+    method: string;
+};
+export declare function unsupportedHostRequestResponse(id: string | number, method: string, hostLabel?: string): string;
+export interface HostApproval {
+    sessionId: string;
+    requestId: string;
+    connectionId?: unknown;
+    generation?: unknown;
+    request?: {
+        toolName?: unknown;
+        args?: Record<string, unknown>;
+    };
+    childHost?: {
+        activate?: unknown;
+        release?: unknown;
+    };
+}
+export interface HostRequest {
+    kind: "authority" | "loopback";
+    capability: string;
+    message: Record<string, unknown>;
+    line: string;
+    approval?: HostApproval;
+}
+export declare function classifyHostRequest(message: unknown, line: string): HostRequest | undefined;
+/** Consume private worker requests before they enter untrusted client routing. */
+export declare function interceptHostRequest(message: unknown, line: string, options: {
+    runtime: HostRuntime;
+    sendLine(line: string): void;
+    approve(params: Record<string, unknown>): void;
+}): boolean;

package/dist/host-requests.js

@@ -0,0 +1,98 @@
+const LOOPBACKS = Object.freeze({
+    __browser_action__: "browser",
+    __credential_action__: "credential.browserCookie",
+    __workspace_action__: "workspace.switch",
+    __panel_action__: "panel",
+});
+function loopbackCapability(toolName) {
+    if (typeof toolName !== "string" || toolName === "__ask_user__")
+        return undefined;
+    if (Object.hasOwn(LOOPBACKS, toolName))
+        return LOOPBACKS[toolName];
+    return toolName.startsWith("__") ? toolName : undefined;
+}
+function unsupportedText(capability, hostLabel) {
+    return `${capability} is not supported by this host (${hostLabel})`;
+}
+/** Compatibility surface for S0 callers. */
+export function unsupportedLoopbackCapability(toolName, host) {
+    const capability = loopbackCapability(toolName);
+    return capability === "panel" && host.panels ? undefined : capability;
+}
+export function unsupportedLoopbackAnswer(capability, hostLabel = "headless serve") {
+    const text = unsupportedText(capability, hostLabel);
+    return JSON.stringify({
+        ok: false,
+        failure: "unsupported",
+        capability,
+        error: text,
+        detail: text,
+    });
+}
+/** AskUser expects human text, so an unsupported host must never approve a synthetic answer. */
+export function unsupportedAskUserDecision(hostLabel) {
+    return {
+        approved: false,
+        failure: "unavailable",
+        reason: unsupportedText("user.ask", hostLabel),
+    };
+}
+export function isHostAuthorityRequest(message) {
+    return ((typeof message.id === "string" || typeof message.id === "number") &&
+        typeof message.method === "string" &&
+        message.method.startsWith("desktop/"));
+}
+export function unsupportedHostRequestResponse(id, method, hostLabel = "headless serve") {
+    return JSON.stringify({
+        jsonrpc: "2.0",
+        id,
+        error: {
+            code: -32601,
+            message: unsupportedText(method, hostLabel),
+            data: { failure: "unsupported", capability: method },
+        },
+    });
+}
+export function classifyHostRequest(message, line) {
+    if (!message || typeof message !== "object" || Array.isArray(message))
+        return undefined;
+    const frame = message;
+    if (isHostAuthorityRequest(frame))
+        return { kind: "authority", capability: frame.method, message: frame, line };
+    if (frame.method !== "agent/approvalRequest")
+        return undefined;
+    const approval = frame.params;
+    if (!approval || typeof approval.requestId !== "string" || typeof approval.sessionId !== "string")
+        return undefined;
+    const capability = loopbackCapability(approval.request?.toolName);
+    return capability ? { kind: "loopback", capability, message: frame, line, approval } : undefined;
+}
+/** Consume private worker requests before they enter untrusted client routing. */
+export function interceptHostRequest(message, line, options) {
+    const request = classifyHostRequest(message, line);
+    if (!request)
+        return false;
+    if (options.runtime.supports(request.capability))
+        return options.runtime.dispatch(request);
+    if (request.kind === "authority") {
+        const frame = request.message;
+        options.sendLine(unsupportedHostRequestResponse(frame.id, frame.method, options.runtime.adapter.label));
+    }
+    else {
+        const approval = request.approval;
+        // Child browser lifetime frames are one-way; no pending approval exists.
+        if (approval.childHost?.activate === true || approval.childHost?.release === true)
+            return true;
+        options.approve({
+            sessionId: approval.sessionId,
+            requestId: approval.requestId,
+            connectionId: approval.connectionId,
+            generation: approval.generation,
+            decision: {
+                approved: true,
+                answer: unsupportedLoopbackAnswer(request.capability, options.runtime.adapter.label),
+            },
+        });
+    }
+    return true;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { HostRuntime, type HostAdapter, type HostService } from "./runtime.js";
+export { classifyHostRequest, interceptHostRequest, isHostAuthorityRequest, unsupportedAskUserDecision, unsupportedHostRequestResponse, unsupportedLoopbackAnswer, unsupportedLoopbackCapability, type HostApproval, type HostRequest, type ServeHostCapabilities, } from "./host-requests.js";

package/dist/index.js

@@ -0,0 +1,2 @@
+export { HostRuntime } from "./runtime.js";
+export { classifyHostRequest, interceptHostRequest, isHostAuthorityRequest, unsupportedAskUserDecision, unsupportedHostRequestResponse, unsupportedLoopbackAnswer, unsupportedLoopbackCapability, } from "./host-requests.js";

package/dist/runtime.d.ts

@@ -0,0 +1,34 @@
+import type { Contracts } from "@cjhyy/code-shell-core";
+import type { HostRequest } from "./host-requests.js";
+/** Platform mechanisms stay in the adapter; services do not import Electron. */
+export interface HostAdapter {
+    kind: "electron" | "headless" | "container";
+    label: string;
+    id?: string;
+    contracts?: Contracts;
+    start?(): void;
+    stop?(): void;
+}
+export interface HostService {
+    id: string;
+    capabilities: readonly string[];
+    /** Missing handlers mean the adapter's existing downstream route owns the request. */
+    hostRequests?: Readonly<Record<string, (request: HostRequest) => boolean>>;
+    start?(adapter: HostAdapter): void;
+    stop?(): void;
+}
+/** Step 1.1 registry. Large services and the v2 client transport migrate separately. */
+export declare class HostRuntime {
+    readonly adapter: HostAdapter;
+    private readonly services;
+    private readonly owners;
+    private readonly started;
+    private state;
+    constructor(adapter: HostAdapter, services?: readonly HostService[]);
+    register(service: HostService): void;
+    start(): void;
+    stop(): void;
+    capabilities(): string[];
+    supports(capability: string): boolean;
+    dispatch(request: HostRequest): boolean;
+}

package/dist/runtime.js

@@ -0,0 +1,101 @@
+/** Step 1.1 registry. Large services and the v2 client transport migrate separately. */
+export class HostRuntime {
+    adapter;
+    services = new Map();
+    owners = new Map();
+    started = [];
+    state = "created";
+    constructor(adapter, services = []) {
+        this.adapter = adapter;
+        for (const service of services)
+            this.register(service);
+    }
+    register(service) {
+        if (this.state !== "created")
+            throw new Error("Host services must register before start");
+        if (!service.id || this.services.has(service.id))
+            throw new Error("Duplicate host service");
+        const capabilities = new Set();
+        for (const capability of service.capabilities) {
+            if (!capability || capabilities.has(capability) || this.owners.has(capability))
+                throw new Error(`Duplicate host capability: ${capability}`);
+            capabilities.add(capability);
+        }
+        for (const capability of Object.keys(service.hostRequests ?? {})) {
+            if (!service.capabilities.includes(capability))
+                throw new Error(`Undeclared host capability: ${capability}`);
+        }
+        this.services.set(service.id, service);
+        for (const capability of service.capabilities)
+            this.owners.set(capability, service);
+    }
+    start() {
+        if (this.state === "running")
+            return;
+        if (this.state === "stopped")
+            throw new Error("Host runtime is stopped");
+        if (this.state === "starting")
+            throw new Error("Host runtime is already starting");
+        this.state = "starting";
+        try {
+            this.adapter.start?.();
+            if (this.state !== "starting")
+                throw new Error("Host runtime stopped during start");
+            for (const service of this.services.values()) {
+                this.started.push(service);
+                service.start?.(this.adapter);
+                if (this.state !== "starting")
+                    throw new Error("Host runtime stopped during start");
+            }
+            this.state = "running";
+        }
+        catch (error) {
+            let cleanupErrors;
+            try {
+                this.stop();
+            }
+            catch (cleanup) {
+                cleanupErrors = cleanup instanceof AggregateError ? cleanup.errors : [cleanup];
+            }
+            if (cleanupErrors) {
+                throw new AggregateError([error, ...cleanupErrors], "Host startup and rollback failed", {
+                    cause: error,
+                });
+            }
+            throw error;
+        }
+    }
+    stop() {
+        if (this.state === "stopped")
+            return;
+        this.state = "stopped";
+        const errors = [];
+        for (const service of this.started.splice(0).reverse()) {
+            try {
+                service.stop?.();
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
+        try {
+            this.adapter.stop?.();
+        }
+        catch (error) {
+            errors.push(error);
+        }
+        if (errors.length)
+            throw new AggregateError(errors, "Host shutdown failed");
+    }
+    capabilities() {
+        return [...this.owners.keys()];
+    }
+    supports(capability) {
+        return this.state === "running" && this.owners.has(capability);
+    }
+    dispatch(request) {
+        if (!this.supports(request.capability))
+            return false;
+        return (this.owners.get(request.capability)?.hostRequests?.[request.capability]?.(request) ?? false);
+    }
+}

package/package.json

@@ -1,6 +1,38 @@
 {
   "name": "@cjhyy/code-shell-host",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.9.44",
+  "description": "Host-neutral capability registry and worker request dispatch for CodeShell hosts.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "bun run clean && tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\""
+  },
+  "dependencies": {
+    "@cjhyy/code-shell-core": "0.9.44"
+  },
+  "engines": {
+    "node": ">=20.10"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cjhyy/codeshell.git",
+    "directory": "packages/host"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT"
+}