@cjhyy/code-shell-server 0.9.44 → 0.9.46

package/dist/attachment-service.d.ts

@@ -65,6 +65,8 @@ export declare const DRAFT_ATTACHMENT_TTL_MS: number;
 export declare const SENT_ATTACHMENT_TTL_MS: number;
 export declare const MAX_STAGED_IMAGE_BYTES: number;
 export declare const MAX_STAGED_FILE_BYTES: number;
+/** Whether image staging accepts this MIME type (after normalization). */
+export declare function isStageableImageMime(mime: string): boolean;
 export declare function stageImageDataUrl(input: StageImageDataUrlInput): Promise<InputAttachmentMeta>;
 /** Stage already-transferred bytes without expanding them back through base64. */
 export declare function stageImageBytes(input: StageImageBytesInput): Promise<InputAttachmentMeta>;

package/dist/attachment-service.js

@@ -1,4 +1,4 @@
-import { createHash } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { constants as fsConstants } from "node:fs";
 import { appendFile, lstat, mkdir, open, readdir, realpath, rename, rm, stat, writeFile, } from "node:fs/promises";
 import { basename, extname, join, relative, resolve, sep } from "node:path";
@@ -49,7 +49,10 @@ const IMAGE_MIME_EXT = {
     "image/gif": ".gif",
 };
 const ALLOWED_IMAGE_MIMES = new Set(Object.keys(IMAGE_MIME_EXT));
-let idCounter = 0;
+/** Whether image staging accepts this MIME type (after normalization). */
+export function isStageableImageMime(mime) {
+    return ALLOWED_IMAGE_MIMES.has(normalizeMime(mime));
+}
 export async function stageImageDataUrl(input) {
     const parsed = parseDataUrl(input.dataUrl);
     if (!parsed || !ALLOWED_IMAGE_MIMES.has(parsed.mime)) {
@@ -128,9 +131,8 @@ async function stageImageBuffer(input, mime, buffer) {
     }
     const relPath = normalizePath(relative(cwd, absPath));
     const createdAt = Date.now();
-    idCounter += 1;
     const meta = {
-        id: `att_${sha16}_${idCounter.toString(36)}`,
+        id: `att_${sha16}_${randomUUID()}`,
         sessionId: input.sessionId,
         kind: "image",
         origin: input.origin,
@@ -181,9 +183,8 @@ export async function stageFileBytes(input) {
     }
     const relPath = normalizePath(relative(cwd, absPath));
     const createdAt = Date.now();
-    idCounter += 1;
     const meta = {
-        id: `att_${sha16}_${idCounter.toString(36)}`,
+        id: `att_${sha16}_${randomUUID()}`,
         sessionId: input.sessionId,
         kind: "file",
         origin: input.origin,
@@ -286,29 +287,41 @@ export async function cleanupAttachments(input) {
             sessionsRemoved.push(sessionId);
             continue;
         }
-        const latest = latestAttachmentState(records);
-        for (const state of latest.values()) {
-            const createdAt = state.createdAt ?? 0;
-            const sentAt = state.sentAt;
-            const isSent = typeof sentAt === "number";
-            const ttl = isSent ? SENT_ATTACHMENT_TTL_MS : DRAFT_ATTACHMENT_TTL_MS;
-            const basis = isSent ? sentAt : createdAt;
-            if (!basis || now - basis < ttl)
-                continue;
-            if (!state.absPath || !(await pathExistsInside(state.absPath, root)))
+        const byPath = new Map();
+        for (const state of latestAttachmentState(records).values()) {
+            if (!state.absPath)
                 continue;
-            await rm(state.absPath, { force: true }).catch(() => undefined);
-            removed.push(state.absPath);
-            await appendManifest(sessionDir, {
-                event: "cleanup",
-                id: state.id,
-                sessionId,
-                absPath: state.absPath,
-                relPath: state.relPath,
-                path: state.path,
-                sha256: state.sha256,
-                cleanedAt: now,
+            const references = byPath.get(state.absPath) ?? [];
+            references.push(state);
+            byPath.set(state.absPath, references);
+        }
+        for (const [absPath, references] of byPath) {
+            const expired = references.filter((state) => {
+                const isSent = typeof state.sentAt === "number";
+                const ttl = isSent ? SENT_ATTACHMENT_TTL_MS : DRAFT_ATTACHMENT_TTL_MS;
+                const basis = isSent ? state.sentAt : (state.createdAt ?? 0);
+                return !!basis && now - basis >= ttl;
             });
+            if (expired.length === 0 || !(await pathExistsInside(absPath, root)))
+                continue;
+            // Staging deduplicates image bytes across IDs at this same canonical path.
+            // Retire expired IDs independently; a live or unknown-age reference keeps the file.
+            if (expired.length === references.length) {
+                await rm(absPath, { force: true }).catch(() => undefined);
+                removed.push(absPath);
+            }
+            for (const state of expired) {
+                await appendManifest(sessionDir, {
+                    event: "cleanup",
+                    id: state.id,
+                    sessionId,
+                    absPath: state.absPath,
+                    relPath: state.relPath,
+                    path: state.path,
+                    sha256: state.sha256,
+                    cleanedAt: now,
+                });
+            }
         }
     }
     return { removed, sessionsRemoved };

package/dist/bin/code-shell-link-cleanup.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/code-shell-link-cleanup.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { runLegacyLinkCleanupCli } from "../links/legacy-cleanup-cli.js";
+process.exitCode = await runLegacyLinkCleanupCli();

package/dist/desktop-web/http-api.d.ts

@@ -1,4 +1,5 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
+import type { ModelTraceListQuery } from "@cjhyy/code-shell-core/internal";
 import type { TrustedDeviceStore } from "../mobile-remote/trusted-device-store.js";
 export interface DesktopWebRequestContext {
     deviceId: string;
@@ -14,6 +15,8 @@ export interface DesktopWebApiOptions {
     sessionRootDir: string;
     /** Input is untrusted. Return only a workspace already known to Desktop. */
     resolveWorkspace: (input: string | undefined, deviceId: string) => string | undefined | Promise<string | undefined>;
+    /** Related diagnostic scopes are resolved by Desktop's project authority, per device. */
+    resolveModelTraceScopes?: (cwd: string, deviceId: string) => ModelTraceListQuery["workspaceScopes"] | Promise<ModelTraceListQuery["workspaceScopes"]>;
     /**
      * The existing Desktop AgentBridge owns this run/configuration admission lock.
      * Reject active runs with status 409, hold the lock through write + hot reload,

package/dist/desktop-web/http-api.js

@@ -1,6 +1,8 @@
 import { describeEnvironment, environmentIdentity } from "../environment-identity.js";
 import { randomBytes, randomUUID } from "node:crypto";
 import { isAbsolute } from "node:path";
+import { join } from "node:path";
+import { createModelTraceHttp } from "../model-trace-http.js";
 import { createHubConfiguration, HubConfigurationError } from "../hub/configuration.js";
 import { createHubFiles } from "../hub/files.js";
 import { createHubMcpConfiguration } from "../hub/mcp-configuration.js";
@@ -180,6 +182,8 @@ export function createDesktopWebApi(options) {
     function createServices(cwd) {
         const shared = {
             cwd,
+            traceStorageDir: join(options.sessionRootDir, ".model-traces"),
+            traceSource: "desktop-web",
             isAuthorized: authorized,
             ownerId: owner,
             withMutation: async (write) => {
@@ -213,12 +217,23 @@ export function createDesktopWebApi(options) {
             isRunning: options.isRunning,
             onChanged: (id) => options.onSessionsChanged?.(cwd, id),
         });
+        const traces = createModelTraceHttp({
+            storageDir: join(options.sessionRootDir, ".model-traces"),
+            workspacePath: cwd,
+            isAuthorized: authorized,
+            resolveWorkspaceScopes: async (request) => {
+                const identity = identities.get(request);
+                if (!identity || !(await authorized(request)))
+                    return undefined;
+                return options.resolveModelTraceScopes?.(cwd, identity.session.deviceId);
+            },
+        });
         return {
             configuration,
             mcp,
             active: 0,
             async handle(request, response) {
-                for (const service of [configuration, skills, mcp, files, history])
+                for (const service of [configuration, skills, mcp, files, history, traces])
                     if (await service.handle(request, response))
                         return true;
                 return false;

package/dist/hub/configuration.d.ts

@@ -1,5 +1,5 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
-import { probeConfiguredModel } from "./model-probe.js";
+import { probeConfiguredModel } from "@cjhyy/code-shell-host";
 export declare class HubConfigurationError extends Error {
     readonly status: number;
     constructor(status: number, message: string);
@@ -13,6 +13,9 @@ export interface HubConfigurationOptions {
     ownerId?: (request: IncomingMessage) => Promise<string | undefined>;
     /** Test seam; production always uses the shared Core client. */
     probe?: typeof probeConfiguredModel;
+    /** Trusted Host route for auxiliary connection probes; never browser-selected. */
+    traceStorageDir?: string;
+    traceSource?: string;
 }
 /** The caller must authenticate and check Origin before dispatching any request here. */
 export declare function createHubConfiguration(options: HubConfigurationOptions): {
@@ -31,7 +34,7 @@ export declare function createHubConfiguration(options: HubConfigurationOptions)
             id: string;
             revision: string;
             catalogId: string;
-            tag: "image" | "text" | "video" | "audio" | "speech";
+            tag: "image" | "speech" | "audio" | "text" | "video";
             model: string;
             baseUrl: string;
             hasApiKey: boolean;
@@ -48,7 +51,7 @@ export declare function createHubConfiguration(options: HubConfigurationOptions)
             disabledReason?: string | undefined;
             name: string;
             description: string;
-            source: "user" | "project" | "plugin" | "panel-app";
+            source: "project" | "user" | "plugin" | "panel-app";
             enabled: boolean;
         }[];
         mcpServers: {

package/dist/hub/configuration.js

@@ -2,7 +2,8 @@ import { createHash, randomUUID } from "node:crypto";
 import { join } from "node:path";
 import { SettingsManager, invalidateSkillCache, mergePluginMcpServers, scanSkills, userHome, } from "@cjhyy/code-shell-core";
 import { computeEffectiveDisabledLists, getMergedCatalog } from "@cjhyy/code-shell-core/internal";
-import { probeConfiguredModel } from "./model-probe.js";
+import { withModelTraceContext } from "@cjhyy/code-shell-core/internal";
+import { probeConfiguredModel } from "@cjhyy/code-shell-host";
 const ROOT = "/api/v1/configuration";
 const MAX_BODY_BYTES = 64 * 1024;
 const MAX_SKILL_BYTES = 2 * 1024 * 1024;
@@ -173,19 +174,26 @@ export function createHubConfiguration(options) {
     }
     function updateDefaults(input) {
         knownFields(input, ["text", "auxText"]);
-        const text = boundedString(input.text, "text", 128);
+        // Each field is optional so a form submits only what it changed; the merge
+        // happens here under the configuration lock, and a stale form can no longer
+        // revert a default another device saved meanwhile.
+        if (input.text === undefined && input.auxText === undefined) {
+            throw new HubConfigurationError(400, "text or auxText is required");
+        }
+        const text = input.text === undefined ? undefined : boundedString(input.text, "text", 128);
         const auxText = input.auxText === undefined || input.auxText === null
             ? input.auxText
             : boundedString(input.auxText, "auxText", 128);
         const manager = settingsManager();
         manager.mutateSettingsForScope("local", options.cwd, (current) => {
             const effective = settingsManager().get();
-            requireTextConnection(effective, text);
+            if (text !== undefined)
+                requireTextConnection(effective, text);
             if (auxText)
                 requireTextConnection(effective, auxText);
             current.defaults = {
                 ...objectOrEmpty(current.defaults),
-                text,
+                ...(text !== undefined ? { text } : {}),
                 // Empty means the core background-model resolver follows the main model.
                 ...(auxText !== undefined ? { auxText: auxText ?? "" } : {}),
             };
@@ -377,9 +385,14 @@ export function createHubConfiguration(options) {
                 try {
                     // Register before this final auth await, so a concurrent revoke also aborts this probe.
                     await authorize(req);
-                    const result = await (options.probe ?? probeConfiguredModel)(settings, id, {
+                    const result = await withModelTraceContext({
+                        ...(options.traceStorageDir ? { storageDir: options.traceStorageDir } : {}),
+                        workspacePath: options.cwd,
+                        source: options.traceSource ?? "server",
+                        purpose: "connection_probe",
+                    }, () => (options.probe ?? probeConfiguredModel)(settings, id, {
                         signal: controller.signal,
-                    });
+                    }));
                     await authorize(req);
                     json(res, 200, result);
                 }

package/dist/hub/mcp-probe.d.ts

@@ -1,24 +1,4 @@
-import { type MCPServerConfig } from "@cjhyy/code-shell-core";
-export interface HubMcpProbeResult {
-    name: string;
-    status: "ok" | "error" | "cancelled";
-    checkedAt: string;
-    durationMs: number;
-    toolCount?: number;
-    truncated?: boolean;
-    tools?: {
-        name: string;
-        description?: string;
-        allowed: boolean;
-    }[];
-    error?: {
-        code: string;
-        message: string;
-    };
-}
-/** Explicit, bounded sibling connection; configuration reads never invoke this function. */
-export declare function probeHubMcp(config: MCPServerConfig, options: {
-    cwd: string;
-    signal: AbortSignal;
-    timeoutMs?: number;
-}): Promise<HubMcpProbeResult>;
+import { probeMcp, type McpProbeResult } from "@cjhyy/code-shell-host";
+export type HubMcpProbeResult = McpProbeResult;
+/** HTTP authority and cancellation stay in mcp-configuration; only server-facing wording lives here. */
+export declare function probeHubMcp(...args: Parameters<typeof probeMcp>): Promise<HubMcpProbeResult>;