@cjhyy/code-shell-server 0.9.44 → 0.9.46

package/dist/links/diagnostics.js

@@ -0,0 +1,184 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { randomUUID } from "node:crypto";
+import { performance } from "node:perf_hooks";
+const defaults = {
+    authorization: "authorization_check_failed",
+    body_validation: "request_body_invalid",
+    input_validation: "input_validation_failed",
+    host_store_read: "host_store_read_failed",
+    remote_configuration: "remote_configuration_invalid",
+    remote_catalog: "catalog_unexpected_error",
+    mode_selection: "auth_mode_unavailable",
+    connection_review: "connection_review_failed",
+    job_creation: "authorization_job_failed",
+    final_authorization: "final_authorization_failed",
+};
+const internalCodes = new Set([
+    ...Object.values(defaults),
+    "host_store_unreadable",
+    "remote_configuration_missing",
+    "catalog_network",
+    "catalog_timeout",
+    "catalog_http_status",
+    "catalog_invalid_json",
+    "catalog_invalid_schema",
+    "catalog_unreviewed_capability",
+    "catalog_unsupported_auth",
+    "catalog_response_limit",
+    "catalog_unavailable",
+    "provider_capability_missing",
+    "job_capacity_exceeded",
+    "remote_authorization_invalid",
+]);
+const publicCodes = new Set([
+    "invalid_request",
+    "login_required",
+    "not_found",
+    "read_only",
+    "conflict",
+    "busy",
+    "provider_rejected",
+    "cli_unavailable",
+    "authorization_failed",
+    "authorization_expired",
+    "cancelled",
+    "unavailable",
+]);
+const authorizationStates = new Set(["pending", "connected", "failed", "cancelled"]);
+const activeTrace = new AsyncLocalStorage();
+class AuthorizationTrace {
+    sink;
+    transport;
+    requestId = randomUUID();
+    startedAt = performance.now();
+    active = true;
+    stage = "authorization";
+    failure;
+    identity = {};
+    constructor(sink, transport = "http") {
+        this.sink = sink;
+        this.transport = transport;
+    }
+    run(operation) {
+        return activeTrace.run(this, operation);
+    }
+    isActive() {
+        return this.active;
+    }
+    setStage(stage) {
+        if (!this.active)
+            return;
+        this.stage = stage;
+        this.failure = undefined;
+        this.emit({ outcome: "stage", stage });
+    }
+    setIdentity(identity) {
+        if (this.active)
+            this.identity = { ...identity };
+    }
+    setFailure(failure) {
+        if (!this.active)
+            return;
+        if (failure.internalCode === "authorization_check_failed" &&
+            this.stage === "final_authorization")
+            failure = { stage: "final_authorization", internalCode: "final_authorization_failed" };
+        this.failure = {
+            stage: failure.stage,
+            internalCode: internalCodes.has(failure.internalCode)
+                ? failure.internalCode
+                : defaults[failure.stage],
+            ...(Number.isInteger(failure.upstreamStatus) &&
+                failure.upstreamStatus >= 100 &&
+                failure.upstreamStatus <= 599
+                ? { upstreamStatus: failure.upstreamStatus }
+                : {}),
+        };
+    }
+    complete(httpStatus, publicCode, authorizationState) {
+        if (!this.active)
+            return;
+        this.emit(publicCode
+            ? {
+                outcome: "failure",
+                ...(this.failure ?? { stage: this.stage, internalCode: defaults[this.stage] }),
+                publicCode: publicCodes.has(publicCode) ? publicCode : "unavailable",
+                httpStatus: this.httpStatus(httpStatus),
+            }
+            : {
+                outcome: "success",
+                stage: this.stage,
+                httpStatus: this.httpStatus(httpStatus),
+                ...(authorizationState && authorizationStates.has(authorizationState)
+                    ? { authorizationState }
+                    : {}),
+            });
+    }
+    httpStatus(status) {
+        return Number.isInteger(status) && status >= 100 && status <= 599 ? status : 503;
+    }
+    /** Detached authorization jobs inherit ALS; they must lose authority to edit this trace. */
+    deactivate() {
+        this.active = false;
+    }
+    emit(value) {
+        const event = Object.freeze({
+            event: "link_authorization",
+            transport: this.transport,
+            requestId: this.requestId,
+            elapsedMs: Math.max(0, Math.round(performance.now() - this.startedAt)),
+            ...this.identity,
+            ...value,
+        });
+        try {
+            if (this.sink) {
+                void Promise.resolve(this.sink(event)).catch(() => { });
+            }
+            else {
+                process.stderr.write(`${JSON.stringify(event)}\n`);
+            }
+        }
+        catch {
+            // Observability must never change an authorization result or reveal the sink's exception.
+        }
+    }
+}
+export function createLinkAuthorizationTrace(sink) {
+    return new AuthorizationTrace(sink);
+}
+/** Native Host callers share the same diagnostics; HTTP already owns its longer request lifetime. */
+export async function withLinkAuthorizationTrace(sink, operation, failure) {
+    if (activeTrace.getStore()?.isActive())
+        return operation();
+    const trace = new AuthorizationTrace(sink, "host");
+    return trace.run(async () => {
+        try {
+            trace.setStage("authorization");
+            const result = await operation();
+            trace.complete(200, undefined, result.state);
+            return result;
+        }
+        catch (error) {
+            try {
+                const mapped = failure(error);
+                trace.complete(mapped.status, mapped.code);
+            }
+            catch {
+                trace.complete(503, "unavailable");
+            }
+            throw error;
+        }
+        finally {
+            trace.deactivate();
+        }
+    });
+}
+export function authorizationDiagnosticStage(stage) {
+    activeTrace.getStore()?.setStage(stage);
+}
+/** Callers must select identity values from the compiled provider/method/mode catalog. */
+export function authorizationDiagnosticIdentity(identity) {
+    activeTrace.getStore()?.setIdentity(identity);
+}
+export function authorizationDiagnosticFailure(stage, internalCode, upstreamStatus) {
+    activeTrace.getStore()?.setFailure({ stage, internalCode, upstreamStatus });
+}

package/dist/links/http.d.ts

@@ -1,6 +1,6 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { type LinkServiceOptions } from "./service.js";
-import type { LinkAuthorizationResponse, LinkConnectionInput, LinkOperationContext, TokenConnectionInput } from "./types.js";
+import type { LinkAuthorizationResponse, LinkAuthorization, LinkConnectionInput, LinkOperationContext, TokenConnectionInput } from "./types.js";
 export interface LinkHttpOptions extends LinkServiceOptions {
     /** Project gateways own the public callback; private runtimes must not advertise it themselves. */
     browserHandoff?: boolean;
@@ -16,6 +16,7 @@ export declare function createLinkHttp(options: LinkHttpOptions): {
         connectToken: (context: LinkOperationContext, input: TokenConnectionInput) => Promise<import("@cjhyy/code-shell-link").MaskedLinkConnection>;
         connectCli: (context: LinkOperationContext, input: LinkConnectionInput) => Promise<import("@cjhyy/code-shell-link").MaskedLinkConnection>;
         cliStatus: (context: LinkOperationContext, rawProviderId: unknown) => Promise<{
+            accountId?: string | undefined;
             account?: string | undefined;
             providerId: import("@cjhyy/code-shell-core").CliLinkProviderId;
             command: string;
@@ -24,14 +25,15 @@ export declare function createLinkHttp(options: LinkHttpOptions): {
         }>;
         rename: (context: LinkOperationContext, id: string, label: string, expectedRevision: string) => Promise<import("@cjhyy/code-shell-link").MaskedLinkConnection>;
         disconnect: (context: LinkOperationContext, id: string, expectedRevision: string) => Promise<void>;
-        startDeviceAuth: (context: LinkOperationContext, input: LinkConnectionInput) => Promise<import("@cjhyy/code-shell-link").LinkAuthorization>;
-        startAuthorization: (context: LinkOperationContext, input: LinkConnectionInput, rawAuthModeId: unknown) => Promise<import("@cjhyy/code-shell-link").LinkAuthorization>;
-        respondAuthorization: (context: LinkOperationContext, id: string, response: LinkAuthorizationResponse) => Promise<import("@cjhyy/code-shell-link").LinkAuthorization>;
-        refreshRemoteCatalog: (context: LinkOperationContext) => Promise<void>;
-        startRemoteAuth: (context: LinkOperationContext, input: LinkConnectionInput) => Promise<import("@cjhyy/code-shell-link").LinkAuthorization>;
-        completeRemoteAuth: (context: LinkOperationContext, id: string, callbackUrl: string) => Promise<import("@cjhyy/code-shell-link").LinkAuthorization>;
+        startDeviceAuth: (context: LinkOperationContext, input: LinkConnectionInput) => Promise<LinkAuthorization>;
+        startAuthorization: (context: LinkOperationContext, input: LinkConnectionInput, rawAuthModeId: unknown) => Promise<LinkAuthorization>;
+        openHostAuthorization: (context: LinkOperationContext, id: string) => Promise<boolean>;
+        respondAuthorization: (context: LinkOperationContext, id: string, response: LinkAuthorizationResponse) => Promise<LinkAuthorization>;
+        refreshRemoteCatalog: (context: LinkOperationContext, force?: boolean) => Promise<void>;
+        startRemoteAuth: (context: LinkOperationContext, input: LinkConnectionInput) => Promise<LinkAuthorization>;
+        completeRemoteAuth: (context: LinkOperationContext, id: string, callbackUrl: string) => Promise<LinkAuthorization>;
         retryRemoteCleanup: () => Promise<void>;
-        authorization: (context: LinkOperationContext, id: string) => Promise<import("@cjhyy/code-shell-link").LinkAuthorization>;
+        authorization: (context: LinkOperationContext, id: string) => Promise<LinkAuthorization>;
         cancelAuthorization: (context: LinkOperationContext, id: string) => Promise<void>;
         cancelOwner: (ownerId: string) => void;
         close: () => void;

package/dist/links/http.js

@@ -1,4 +1,5 @@
 import { createLinkBrowserHandoff } from "./browser-handoff.js";
+import { authorizationDiagnosticStage, createLinkAuthorizationTrace } from "./diagnostics.js";
 import { createLinkService, LinkServiceError, publicLinkError, } from "./service.js";
 const ROOT = "/api/v1/links";
 const MAX_BODY_BYTES = 32 * 1024;
@@ -77,137 +78,155 @@ export function createLinkHttp(options) {
                     abandoned = true;
             };
             response.once("close", onClose);
-            try {
-                const owner = await context(request, () => abandoned || request.aborted);
-                const method = request.method;
-                let result;
-                if (url.pathname === ROOT && method === "GET") {
-                    await service.refreshRemoteCatalog(owner);
-                    const snapshot = service.snapshot();
-                    const configured = options.remoteLink?.();
-                    result = {
-                        ...snapshot,
-                        capabilities: {
-                            ...snapshot.capabilities,
-                            ...(options.browserHandoff !== false &&
-                                configured &&
-                                new URL(configured.redirectUri).pathname === "/link/callback"
-                                ? { browserHandoff: 1 }
-                                : {}),
-                        },
-                    };
-                }
-                else {
-                    const cli = /^\/api\/v1\/links\/providers\/([^/]+)\/cli$/.exec(url.pathname);
-                    const connection = /^\/api\/v1\/links\/connections\/([^/]+)$/.exec(url.pathname);
-                    const remoteComplete = /^\/api\/v1\/links\/authorizations\/([^/]+)\/complete$/.exec(url.pathname);
-                    const handoff = /^\/api\/v1\/links\/authorizations\/([^/]+)\/browser$/.exec(url.pathname);
-                    const authorization = /^\/api\/v1\/links\/authorizations\/([^/]+)$/.exec(url.pathname);
-                    const respond = /^\/api\/v1\/links\/authorizations\/([^/]+)\/responses$/.exec(url.pathname);
-                    if (url.pathname === ROOT + "/authorizations" && method === "POST") {
-                        const input = await body(request);
-                        fields(input, [
-                            "providerId",
-                            "methodId",
-                            "label",
-                            "connectionId",
-                            "expectedRevision",
-                            "authModeId",
-                            "resourceUrl",
-                        ]);
-                        result = await service.startAuthorization(owner, input, input.authModeId);
-                    }
-                    else if (handoff && method === "POST") {
-                        fields(await body(request), []);
-                        const id = decodeURIComponent(handoff[1]);
-                        const check = async () => {
-                            const job = await service.authorization(owner, id);
-                            if (job.state !== "pending")
-                                throw new LinkServiceError(409, "conflict");
-                            return job;
-                        };
+            const trace = url.pathname === ROOT + "/authorizations" && request.method === "POST"
+                ? createLinkAuthorizationTrace(options.onAuthorizationDiagnostic)
+                : undefined;
+            if (trace)
+                response.setHeader("X-Request-ID", trace.requestId);
+            const handle = async () => {
+                try {
+                    authorizationDiagnosticStage("authorization");
+                    const owner = await context(request, () => abandoned || request.aborted);
+                    const method = request.method;
+                    let result;
+                    if (url.pathname === ROOT && method === "GET") {
+                        await service.refreshRemoteCatalog(owner);
+                        const snapshot = service.snapshot();
                         const configured = options.remoteLink?.();
-                        if (!configured)
-                            throw new LinkServiceError(503, "unavailable");
-                        result = browser.create(await check(), {
-                            check: async () => {
-                                await check();
+                        result = {
+                            ...snapshot,
+                            capabilities: {
+                                ...snapshot.capabilities,
+                                ...(options.browserHandoff !== false &&
+                                    configured &&
+                                    new URL(configured.redirectUri).pathname === "/link/callback"
+                                    ? { browserHandoff: 1 }
+                                    : {}),
                             },
-                            complete: (callbackUrl) => service.completeRemoteAuth(owner, id, callbackUrl),
-                            cancel: () => service.cancelAuthorization(owner, id),
-                        }, new URL(configured.redirectUri).origin);
-                    }
-                    else if (respond && method === "POST") {
-                        const input = await body(request);
-                        fields(input, ["stepId", "operation", "input"]);
-                        result = await service.respondAuthorization(owner, decodeURIComponent(respond[1]), input);
-                    }
-                    else if (remoteComplete && method === "POST") {
-                        const input = await body(request);
-                        fields(input, ["callbackUrl"]);
-                        result = await service.completeRemoteAuth(owner, decodeURIComponent(remoteComplete[1]), input.callbackUrl);
-                    }
-                    else if (cli && method === "GET")
-                        result = await service.cliStatus(owner, decodeURIComponent(cli[1]));
-                    else if (authorization && method === "GET")
-                        result = await service.authorization(owner, decodeURIComponent(authorization[1]));
-                    else if (authorization && method === "DELETE") {
-                        await service.cancelAuthorization(owner, decodeURIComponent(authorization[1]));
-                        result = { cancelled: true };
-                    }
-                    else if (method === "POST" &&
-                        [
-                            ROOT + "/connections/token",
-                            ROOT + "/connections/cli",
-                            ROOT + "/authorizations/device",
-                            ROOT + "/authorizations/remote",
-                        ].includes(url.pathname)) {
-                        const input = await body(request);
-                        const token = url.pathname.endsWith("/token");
-                        fields(input, [
-                            "providerId",
-                            "methodId",
-                            "label",
-                            "connectionId",
-                            "expectedRevision",
-                            ...(token ? ["token"] : []),
-                            ...(url.pathname.endsWith("/remote") ? ["resourceUrl"] : []),
-                        ]);
-                        result = token
-                            ? await service.connectToken(owner, input)
-                            : url.pathname.endsWith("/cli")
-                                ? await service.connectCli(owner, input)
-                                : url.pathname.endsWith("/remote")
-                                    ? await service.startRemoteAuth(owner, input)
-                                    : await service.startDeviceAuth(owner, input);
+                        };
                     }
-                    else if (connection && (method === "PATCH" || method === "DELETE")) {
-                        const input = await body(request);
-                        fields(input, method === "PATCH" ? ["label", "expectedRevision"] : ["expectedRevision"]);
-                        const id = decodeURIComponent(connection[1]);
-                        if (method === "PATCH")
-                            result = await service.rename(owner, id, input.label, input.expectedRevision);
-                        else {
-                            await service.disconnect(owner, id, input.expectedRevision);
-                            result = { removed: true };
+                    else {
+                        const cli = /^\/api\/v1\/links\/providers\/([^/]+)\/cli$/.exec(url.pathname);
+                        const connection = /^\/api\/v1\/links\/connections\/([^/]+)$/.exec(url.pathname);
+                        const remoteComplete = /^\/api\/v1\/links\/authorizations\/([^/]+)\/complete$/.exec(url.pathname);
+                        const handoff = /^\/api\/v1\/links\/authorizations\/([^/]+)\/browser$/.exec(url.pathname);
+                        const authorization = /^\/api\/v1\/links\/authorizations\/([^/]+)$/.exec(url.pathname);
+                        const respond = /^\/api\/v1\/links\/authorizations\/([^/]+)\/responses$/.exec(url.pathname);
+                        if (url.pathname === ROOT + "/authorizations" && method === "POST") {
+                            authorizationDiagnosticStage("body_validation");
+                            const input = await body(request);
+                            fields(input, [
+                                "providerId",
+                                "methodId",
+                                "label",
+                                "connectionId",
+                                "expectedRevision",
+                                "authModeId",
+                                "resourceUrl",
+                            ]);
+                            result = await service.startAuthorization(owner, input, input.authModeId);
+                        }
+                        else if (handoff && method === "POST") {
+                            fields(await body(request), []);
+                            const id = decodeURIComponent(handoff[1]);
+                            const check = async () => {
+                                const job = await service.authorization(owner, id);
+                                if (job.state !== "pending")
+                                    throw new LinkServiceError(409, "conflict");
+                                return job;
+                            };
+                            const configured = options.remoteLink?.();
+                            if (!configured)
+                                throw new LinkServiceError(503, "unavailable");
+                            result = browser.create(await check(), {
+                                check: async () => {
+                                    await check();
+                                },
+                                complete: (callbackUrl) => service.completeRemoteAuth(owner, id, callbackUrl),
+                                cancel: () => service.cancelAuthorization(owner, id),
+                            }, new URL(configured.redirectUri).origin);
                         }
+                        else if (respond && method === "POST") {
+                            const input = await body(request);
+                            fields(input, ["stepId", "operation", "input"]);
+                            result = await service.respondAuthorization(owner, decodeURIComponent(respond[1]), input);
+                        }
+                        else if (remoteComplete && method === "POST") {
+                            const input = await body(request);
+                            fields(input, ["callbackUrl"]);
+                            result = await service.completeRemoteAuth(owner, decodeURIComponent(remoteComplete[1]), input.callbackUrl);
+                        }
+                        else if (cli && method === "GET")
+                            result = await service.cliStatus(owner, decodeURIComponent(cli[1]));
+                        else if (authorization && method === "GET")
+                            result = await service.authorization(owner, decodeURIComponent(authorization[1]));
+                        else if (authorization && method === "DELETE") {
+                            await service.cancelAuthorization(owner, decodeURIComponent(authorization[1]));
+                            result = { cancelled: true };
+                        }
+                        else if (method === "POST" &&
+                            [
+                                ROOT + "/connections/token",
+                                ROOT + "/connections/cli",
+                                ROOT + "/authorizations/device",
+                                ROOT + "/authorizations/remote",
+                            ].includes(url.pathname)) {
+                            const input = await body(request);
+                            const token = url.pathname.endsWith("/token");
+                            fields(input, [
+                                "providerId",
+                                "methodId",
+                                "label",
+                                "connectionId",
+                                "expectedRevision",
+                                ...(token ? ["token"] : []),
+                                ...(url.pathname.endsWith("/remote") ? ["resourceUrl"] : []),
+                            ]);
+                            result = token
+                                ? await service.connectToken(owner, input)
+                                : url.pathname.endsWith("/cli")
+                                    ? await service.connectCli(owner, input)
+                                    : url.pathname.endsWith("/remote")
+                                        ? await service.startRemoteAuth(owner, input)
+                                        : await service.startDeviceAuth(owner, input);
+                        }
+                        else if (connection && (method === "PATCH" || method === "DELETE")) {
+                            const input = await body(request);
+                            fields(input, method === "PATCH" ? ["label", "expectedRevision"] : ["expectedRevision"]);
+                            const id = decodeURIComponent(connection[1]);
+                            if (method === "PATCH")
+                                result = await service.rename(owner, id, input.label, input.expectedRevision);
+                            else {
+                                await service.disconnect(owner, id, input.expectedRevision);
+                                result = { removed: true };
+                            }
+                        }
+                        else
+                            throw new LinkServiceError(404, "not_found");
                     }
-                    else
-                        throw new LinkServiceError(404, "not_found");
+                    authorizationDiagnosticStage("final_authorization");
+                    await service.assertAuthorized(owner);
+                    json(response, 200, result);
+                    trace?.complete(200, undefined, result.state);
+                }
+                catch (error) {
+                    const failure = error instanceof URIError
+                        ? new LinkServiceError(400, "invalid_request")
+                        : publicLinkError(error);
+                    trace?.complete(failure.status, failure.code);
+                    if (!response.destroyed)
+                        json(response, failure.status, {
+                            error: failure.message,
+                            code: failure.code,
+                            ...(trace ? { requestId: trace.requestId } : {}),
+                        });
                 }
-                await service.assertAuthorized(owner);
-                json(response, 200, result);
-            }
-            catch (error) {
-                const failure = error instanceof URIError
-                    ? new LinkServiceError(400, "invalid_request")
-                    : publicLinkError(error);
-                if (!response.destroyed)
-                    json(response, failure.status, { error: failure.message, code: failure.code });
-            }
-            finally {
-                response.off("close", onClose);
-            }
+                finally {
+                    trace?.deactivate();
+                    response.off("close", onClose);
+                }
+            };
+            await (trace ? trace.run(handle) : handle());
             return true;
         },
     };

package/dist/links/legacy-cleanup-cli.d.ts

@@ -0,0 +1,3 @@
+export declare function runLegacyLinkCleanupCli(argv?: string[], io?: {
+    write: (value: string) => boolean;
+}): Promise<number>;

package/dist/links/legacy-cleanup-cli.js

@@ -0,0 +1,64 @@
+import { parseArgs } from "node:util";
+const HELP = `Usage: code-shell-link-cleanup <inspect|remove> [options]
+
+Offline cleanup of legacy Link-owned connection records. Stop every CodeShell
+Host/worker sharing these credentials before remove. Ordinary OAuth/MCP/model
+credentials, sessions, operation evidence and files are preserved. External CLI
+logins are retained. Remote grants remain in private retirement custody for retry;
+removing a local record does not report successful remote revocation.
+
+  --project <directory>       Project credential layer (default: current directory)
+  --scope <full|project>      Full includes user + project (default: full)
+  --user-dir <directory>      Explicit user credential directory override
+  --operations-root <dir>    Repeat for every custom shared operation/session root
+  -h, --help                 Show help without reading credentials
+`;
+export async function runLegacyLinkCleanupCli(argv = process.argv.slice(2), io = { write: (value) => process.stdout.write(value) }) {
+    try {
+        const { values, positionals } = parseArgs({
+            args: argv,
+            strict: true,
+            allowPositionals: true,
+            options: {
+                project: { type: "string" },
+                scope: { type: "string" },
+                "user-dir": { type: "string" },
+                "operations-root": { type: "string", multiple: true },
+                help: { type: "boolean", short: "h" },
+            },
+        });
+        if (values.help) {
+            io.write(HELP);
+            return 0;
+        }
+        const action = positionals[0];
+        const scope = values.scope ?? "full";
+        if (positionals.length !== 1 ||
+            !["inspect", "remove"].includes(action) ||
+            !["full", "project"].includes(scope) ||
+            Object.entries(values).some(([key, value]) => key !== "help" &&
+                (Array.isArray(value)
+                    ? value.some((item) => !item.trim())
+                    : typeof value === "string" && !value.trim())))
+            throw new Error("arguments");
+        const { CredentialStore, sessionsRoot } = await import("@cjhyy/code-shell-core");
+        const { previewLegacyLinkCleanup, cleanupLegacyLinkConnections } = await import("@cjhyy/code-shell-core/internal");
+        const store = new CredentialStore(values.project ?? process.cwd(), undefined, values["user-dir"]);
+        const preview = previewLegacyLinkCleanup(store, scope);
+        if (action === "inspect") {
+            io.write(`${JSON.stringify({ count: preview.length, connections: preview })}\n`);
+            return 0;
+        }
+        const result = cleanupLegacyLinkConnections({
+            store,
+            scope: scope,
+            operationRoots: [sessionsRoot(), ...(values["operations-root"] ?? [])],
+        });
+        io.write(`${JSON.stringify(result)}\n`);
+        return result.changed.length ? 1 : 0;
+    }
+    catch {
+        io.write("Legacy Link cleanup failed; no successful cleanup is implied. Check arguments, stop Hosts and ensure stores are readable.\n");
+        return 1;
+    }
+}

package/dist/links/providers/defaults.d.ts

@@ -0,0 +1,5 @@
+import type { LocalLinkProviderSpec } from "@cjhyy/code-shell-core/extension";
+/** Temporary injectable helper seam; keeps source and built Host module identities consistent. */
+export type LinkProviderRuntime = Pick<typeof import("@cjhyy/code-shell-core/extension"), "GITHUB_SOURCE_ACTIONS" | "githubSourceEndpoint" | "normalizeGithubSourceResult" | "slackSourceParams" | "normalizeSlackSourceResult" | "githubIssueStateParameters" | "githubRepositoryParameters" | "githubSetStarredParameters" | "FIGMA_RESPONSE_BYTES" | "FIGMA_RESPONSE_TOO_LARGE" | "figmaActionEndpoint" | "figmaActionParameters" | "normalizeFigmaActionResult" | "asArray" | "asRecord" | "firstString" | "intParam" | "linkRequestJson" | "linkRequestStatus" | "pathParam" | "pathSegmentParam" | "pick" | "stringParam">;
+/** Product-owned HTTP implementations. Importing the factory does not install providers. */
+export declare function createDefaultLinkProviders(runtime?: LinkProviderRuntime): readonly LocalLinkProviderSpec[];