@cjhyy/code-shell-core 0.8.20 → 0.9.0

package/dist/automation/desktop-authority-client.d.ts

@@ -0,0 +1,9 @@
+import type { Transport } from "../protocol/transport.js";
+import type { CronCreateAuthority } from "../tool-system/builtin/cron.js";
+declare const DESKTOP_AUTOMATION_CREATE_METHOD = "desktop/automationCreate";
+/**
+ * Worker-side request client. Desktop uses it to keep CronCreate out of the
+ * shared store until Main has resolved project/root and resume authority.
+ */
+export declare function createDesktopAutomationAuthorityClient(transport: Pick<Transport, "send" | "onMessage">): CronCreateAuthority;
+export { DESKTOP_AUTOMATION_CREATE_METHOD };

package/dist/automation/desktop-authority-client.js

@@ -0,0 +1,47 @@
+const DESKTOP_AUTOMATION_CREATE_METHOD = "desktop/automationCreate";
+/**
+ * Worker-side request client. Desktop uses it to keep CronCreate out of the
+ * shared store until Main has resolved project/root and resume authority.
+ */
+export function createDesktopAutomationAuthorityClient(transport) {
+    let nextId = 1;
+    const pending = new Map();
+    transport.onMessage((message) => {
+        if (!message || typeof message !== "object" || !("id" in message) || "method" in message) {
+            return;
+        }
+        const id = String(message.id);
+        const waiter = pending.get(id);
+        if (!waiter)
+            return;
+        pending.delete(id);
+        clearTimeout(waiter.timer);
+        if ("error" in message && message.error) {
+            waiter.reject(new Error(message.error.message));
+            return;
+        }
+        const job = message.result;
+        if (!job || typeof job.id !== "string" || typeof job.name !== "string") {
+            waiter.reject(new Error("Desktop Main returned an invalid automation job"));
+            return;
+        }
+        waiter.resolve(job);
+    });
+    return (input) => {
+        const id = `automation-authority-${nextId++}`;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                pending.delete(id);
+                reject(new Error("Desktop Main automation authority timed out"));
+            }, 30_000);
+            pending.set(id, { resolve, reject, timer });
+            transport.send({
+                jsonrpc: "2.0",
+                id,
+                method: DESKTOP_AUTOMATION_CREATE_METHOD,
+                params: input,
+            });
+        });
+    };
+}
+export { DESKTOP_AUTOMATION_CREATE_METHOD };

package/dist/automation/scheduler.d.ts

@@ -32,6 +32,10 @@ export interface CronJob {
     createdAt: number;
     /** Working directory the job runs in (the project it monitors/edits). */
     cwd?: string;
+    /** Stable desktop project binding. Legacy jobs may omit both identifiers. */
+    projectId?: string;
+    /** Stable root within projectId. */
+    rootId?: string;
     /** IANA timezone for cron-expression schedules (e.g. "Asia/Shanghai"). Default "UTC". */
     timezone?: string;
     /** Permission tier; defaults to read-only when unset. */
@@ -80,6 +84,8 @@ export interface CronExecutionOutcome {
 /** Optional metadata accepted by create(). */
 export interface CreateJobOptions {
     cwd?: string;
+    projectId?: string;
+    rootId?: string;
     timezone?: string;
     permissionLevel?: CronPermissionLevel;
     once?: boolean;
@@ -93,6 +99,8 @@ export interface UpdateJobPatch {
     schedule?: string;
     timezone?: string;
     cwd?: string;
+    projectId?: string | null;
+    rootId?: string | null;
     permissionLevel?: CronPermissionLevel;
 }
 export declare class CronScheduler {

package/dist/automation/scheduler.js

@@ -43,6 +43,7 @@ const MAX_JOB_SCHEDULE_CHARS = 512;
 const MAX_JOB_PROMPT_CHARS = 1024 * 1024;
 const MAX_JOB_CWD_CHARS = 32_768;
 const MAX_JOB_TIMEZONE_CHARS = 128;
+const MAX_JOB_BINDING_ID_CHARS = 512;
 function validateJobFields(input) {
     if (input.name !== undefined &&
         (typeof input.name !== "string" ||
@@ -66,9 +67,24 @@ function validateJobFields(input) {
         throw new Error("automation prompt must be a bounded non-empty string");
     }
     if (input.cwd !== undefined &&
-        (typeof input.cwd !== "string" || input.cwd.length > MAX_JOB_CWD_CHARS || input.cwd.includes("\0"))) {
+        (typeof input.cwd !== "string" ||
+            input.cwd.length > MAX_JOB_CWD_CHARS ||
+            input.cwd.includes("\0"))) {
         throw new Error("automation cwd must be a bounded string");
     }
+    for (const [field, value] of [
+        ["projectId", input.projectId],
+        ["rootId", input.rootId],
+    ]) {
+        if (value !== undefined &&
+            value !== null &&
+            (typeof value !== "string" ||
+                !value ||
+                value.length > MAX_JOB_BINDING_ID_CHARS ||
+                value.includes("\0"))) {
+            throw new Error(`automation ${field} must be a bounded non-empty string`);
+        }
+    }
     if (input.timezone !== undefined &&
         (typeof input.timezone !== "string" ||
             input.timezone.length > MAX_JOB_TIMEZONE_CHARS ||
@@ -361,6 +377,8 @@ export class CronScheduler {
                     runCount: 0,
                     createdAt: Date.now(),
                     ...(opts?.cwd !== undefined ? { cwd: opts.cwd } : {}),
+                    ...(opts?.projectId !== undefined ? { projectId: opts.projectId } : {}),
+                    ...(opts?.rootId !== undefined ? { rootId: opts.rootId } : {}),
                     ...(opts?.timezone !== undefined ? { timezone: opts.timezone } : {}),
                     ...(opts?.permissionLevel !== undefined ? { permissionLevel: opts.permissionLevel } : {}),
                     ...(opts?.once === true ? { once: true } : {}),
@@ -383,6 +401,8 @@ export class CronScheduler {
             runCount: 0,
             createdAt: Date.now(),
             ...(opts?.cwd !== undefined ? { cwd: opts.cwd } : {}),
+            ...(opts?.projectId !== undefined ? { projectId: opts.projectId } : {}),
+            ...(opts?.rootId !== undefined ? { rootId: opts.rootId } : {}),
             ...(opts?.timezone !== undefined ? { timezone: opts.timezone } : {}),
             ...(opts?.permissionLevel !== undefined ? { permissionLevel: opts.permissionLevel } : {}),
             ...(opts?.once === true ? { once: true } : {}),
@@ -532,6 +552,14 @@ export class CronScheduler {
                         job.timezone = patch.timezone;
                     if (patch.cwd !== undefined)
                         job.cwd = patch.cwd;
+                    if (patch.projectId === null)
+                        delete job.projectId;
+                    else if (patch.projectId !== undefined)
+                        job.projectId = patch.projectId;
+                    if (patch.rootId === null)
+                        delete job.rootId;
+                    else if (patch.rootId !== undefined)
+                        job.rootId = patch.rootId;
                     if (patch.permissionLevel !== undefined)
                         job.permissionLevel = patch.permissionLevel;
                     if (scheduleChanged)
@@ -565,6 +593,14 @@ export class CronScheduler {
             job.timezone = patch.timezone;
         if (patch.cwd !== undefined)
             job.cwd = patch.cwd;
+        if (patch.projectId === null)
+            delete job.projectId;
+        else if (patch.projectId !== undefined)
+            job.projectId = patch.projectId;
+        if (patch.rootId === null)
+            delete job.rootId;
+        else if (patch.rootId !== undefined)
+            job.rootId = patch.rootId;
         if (patch.permissionLevel !== undefined)
             job.permissionLevel = patch.permissionLevel;
         // Re-arm only when the schedule definition changed, or when an enabled job

package/dist/automation/store.js

@@ -63,6 +63,15 @@ function normalizeJob(value, strict) {
         (typeof raw.cwd !== "string" || raw.cwd.length > 32_768 || raw.cwd.includes("\0"))) {
         return invalid("cwd");
     }
+    for (const field of ["projectId", "rootId"]) {
+        if (raw[field] !== undefined &&
+            (typeof raw[field] !== "string" ||
+                !raw[field] ||
+                raw[field].length > 512 ||
+                raw[field].includes("\0"))) {
+            return invalid(field);
+        }
+    }
     if (raw.timezone !== undefined &&
         (typeof raw.timezone !== "string" || raw.timezone.length > 128 || raw.timezone.includes("\0"))) {
         return invalid("timezone");
@@ -96,7 +105,9 @@ function normalizeJob(value, strict) {
     }
     let templateSource;
     if (raw.templateSource !== undefined) {
-        if (!raw.templateSource || typeof raw.templateSource !== "object" || Array.isArray(raw.templateSource)) {
+        if (!raw.templateSource ||
+            typeof raw.templateSource !== "object" ||
+            Array.isArray(raw.templateSource)) {
             return invalid("templateSource");
         }
         const source = raw.templateSource;
@@ -137,6 +148,8 @@ function normalizeJob(value, strict) {
         ...(typeof raw.lastRun === "number" ? { lastRun: raw.lastRun } : {}),
         ...(typeof raw.nextRun === "number" ? { nextRun: raw.nextRun } : {}),
         ...(typeof raw.cwd === "string" ? { cwd: raw.cwd } : {}),
+        ...(typeof raw.projectId === "string" ? { projectId: raw.projectId } : {}),
+        ...(typeof raw.rootId === "string" ? { rootId: raw.rootId } : {}),
         ...(typeof raw.timezone === "string" ? { timezone: raw.timezone } : {}),
         ...(raw.permissionLevel === "read-only" ||
             raw.permissionLevel === "workspace-write" ||

package/dist/capabilities/index.d.ts

@@ -18,6 +18,7 @@ export interface CapabilityEngineHookContribution {
 }
 export interface CapabilityDynamicContext {
     cwd: string;
+    workspace: import("../workspace/workspace-context.js").WorkspaceContext;
     preset: AgentPreset;
 }
 export type CapabilityDynamicContextProvider = (context: CapabilityDynamicContext) => string | undefined | Promise<string | undefined>;

package/dist/cli/agent-server-stdio.js

@@ -38,7 +38,7 @@ import { validateSettings } from "../settings/schema.js";
 import { AgentServer } from "../protocol/server.js";
 import { StdioTransport } from "../protocol/transport.js";
 import { createNotification, Methods } from "../protocol/types.js";
-import { setCronChangedSink } from "../tool-system/builtin/cron.js";
+import { setCronChangedSink, setCronCreateAuthority } from "../tool-system/builtin/cron.js";
 import { setModelCatalogChangedSink } from "../tool-system/builtin/edit-model-catalog.js";
 import { setCapabilityChangedSink } from "../tool-system/builtin/install-capability.js";
 import { SettingsManager, noRepoDir } from "../settings/manager.js";
@@ -54,6 +54,7 @@ import { cronScheduler } from "../automation/scheduler.js";
 import { CronStore, defaultCronStorePath } from "../automation/store.js";
 import { resolveLLMConfigForTag } from "../engine/resolve-llm-config.js";
 import { createIpcCredentialAccess, setDefaultCredentialAccess } from "../credentials/access.js";
+import { createDesktopAutomationAuthorityClient } from "../automation/desktop-authority-client.js";
 import { compileComposition } from "../composition/compiler.js";
 /**
  * Load AgentModules from CODE_SHELL_CAPABILITY_MODULES: comma-separated
@@ -260,6 +261,7 @@ const chatManager = new ChatSessionManager({
             // cwd). The slice.cwd spread below is now redundant with this but kept
             // for clarity / explicitness.
             cwd: sessionCwd,
+            workspaceContext: slice.workspaceContext,
             runtime,
             // This stdio worker exists only to serve the desktop app, so every
             // session it creates is a desktop-origin session.
@@ -326,6 +328,7 @@ cronScheduler.loadJobs();
 // ─── Step 5: AgentServer over stdio ──────────────────────────────
 const stdioTransport = new StdioTransport(process.stdin, process.stdout);
 setDefaultCredentialAccess(createIpcCredentialAccess(stdioTransport));
+setCronCreateAuthority(createDesktopAutomationAuthorityClient(stdioTransport));
 // Cron jobs are persisted by this worker but only main arms/executes their
 // timers (this worker keeps setExecutionEnabled(false) above). When an AI tool
 // creates/deletes a cron job here, notify main over stdio so it reloads the

package/dist/engine/engine-workspace-authority.d.ts

@@ -0,0 +1,35 @@
+import type { SessionProjectBinding, SessionState, SessionWorkspace } from "../types.js";
+import { type SessionManager } from "../session/session-manager.js";
+import type { SessionMessageRouter, SessionMessageToolService } from "../session/session-message.js";
+import { type WorkspaceContext } from "../workspace/workspace-context.js";
+export declare class SessionWorkspaceAuthorityTracker {
+    private readonly contexts;
+    remember(sessionId: string, context: WorkspaceContext): void;
+    delete(sessionId: string): void;
+    clear(): void;
+}
+export declare function createAuthorizedSessionMessageService(options: {
+    sessionManager: SessionManager;
+    router: SessionMessageRouter | undefined;
+    sourceSessionId: string;
+    rawTargets: unknown;
+}): SessionMessageToolService | undefined;
+export declare function migrateOwnedSessionMainRoot(options: {
+    sessionManager: SessionManager;
+    activeState?: SessionState;
+    authorities: SessionWorkspaceAuthorityTracker;
+    sessionId: string;
+    project: SessionProjectBinding;
+    mainRoot: string;
+}): SessionWorkspace;
+export declare function setOwnedSessionWorkspace(options: {
+    sessionManager: SessionManager;
+    activeState?: SessionState;
+    sessionId: string;
+    workspace: SessionWorkspace;
+}): SessionWorkspace | null;
+export declare function releaseOwnedSessionWorkspace(options: {
+    sessionManager: SessionManager;
+    activeState?: SessionState;
+    sessionId: string;
+}): SessionWorkspace | null;

package/dist/engine/engine-workspace-authority.js

@@ -0,0 +1,136 @@
+import { assertSafeSessionId } from "../session/session-manager.js";
+import { clearSessionPathApprovalsUnderRoot } from "../tool-system/path-policy.js";
+import { canonicalKey } from "../workspace/canonical-key.js";
+import { removedWorkspaceRootPaths, } from "../workspace/workspace-context.js";
+export class SessionWorkspaceAuthorityTracker {
+    contexts = new Map();
+    remember(sessionId, context) {
+        const previous = this.contexts.get(sessionId);
+        if (previous) {
+            for (const root of removedWorkspaceRootPaths(previous, context)) {
+                clearSessionPathApprovalsUnderRoot(sessionId, root);
+            }
+        }
+        this.contexts.set(sessionId, context);
+    }
+    delete(sessionId) {
+        this.contexts.delete(sessionId);
+    }
+    clear() {
+        this.contexts.clear();
+    }
+}
+export function createAuthorizedSessionMessageService(options) {
+    const { sessionManager, router, sourceSessionId } = options;
+    const sourceRoot = sessionManager.readSessionMainRoot(sourceSessionId);
+    if (!sourceRoot || !router)
+        return undefined;
+    const sourceBinding = sessionManager.readSessionProjectBinding(sourceSessionId);
+    const catalog = [];
+    const seen = new Set();
+    const rawTargets = Array.isArray(options.rawTargets) ? [...options.rawTargets] : [];
+    for (const raw of rawTargets.slice(0, 100)) {
+        if (!raw || typeof raw !== "object" || Array.isArray(raw))
+            continue;
+        const candidate = raw;
+        const sessionId = typeof candidate.sessionId === "string" ? candidate.sessionId : "";
+        try {
+            assertSafeSessionId(sessionId);
+        }
+        catch {
+            continue;
+        }
+        if (seen.has(sessionId))
+            continue;
+        const candidateRoot = typeof candidate.workspaceRoot === "string" ? candidate.workspaceRoot : "";
+        const targetBinding = sessionManager.readSessionProjectBinding(sessionId);
+        if (sourceBinding) {
+            if (targetBinding) {
+                if (targetBinding.projectId !== sourceBinding.projectId)
+                    continue;
+            }
+            else if (canonicalKey(candidateRoot) !== canonicalKey(sourceRoot)) {
+                continue;
+            }
+        }
+        else if (canonicalKey(candidateRoot) !== canonicalKey(sourceRoot)) {
+            continue;
+        }
+        const title = typeof candidate.title === "string" ? candidate.title.trim() : "";
+        if (!title || title.length > 512)
+            continue;
+        const workspaceProfile = typeof candidate.workspaceProfile === "string"
+            ? candidate.workspaceProfile.trim().slice(0, 256)
+            : "";
+        seen.add(sessionId);
+        catalog.push({
+            sessionId,
+            title,
+            workspaceRoot: sourceRoot,
+            ...(workspaceProfile ? { workspaceProfile } : {}),
+        });
+    }
+    const targets = catalog.filter((target) => target.sessionId !== sourceSessionId);
+    return {
+        targets,
+        send: async ({ targetSessionId, message }) => {
+            const target = targets.find((candidate) => candidate.sessionId === targetSessionId);
+            if (!target)
+                throw new Error("target Session is not in the host-authorized project list");
+            if (!message.trim())
+                throw new Error("message is required");
+            if (message.length > 48_000)
+                throw new Error("message exceeds 48000 characters");
+            await router({ sourceSessionId, target, message, catalog });
+            return target;
+        },
+    };
+}
+export function migrateOwnedSessionMainRoot(options) {
+    const { sessionManager, activeState, authorities, sessionId, project, mainRoot } = options;
+    if (!sessionId || !sessionManager.exists(sessionId)) {
+        throw new Error(`Session ${sessionId} does not exist`);
+    }
+    const workspace = { root: mainRoot, kind: "main" };
+    const stateRevision = sessionManager.migrateSessionMainRoot(sessionId, project, mainRoot);
+    if (activeState?.sessionId === sessionId) {
+        Object.assign(activeState, {
+            project: { ...project },
+            cwd: mainRoot,
+            workspace,
+            stateRevision,
+        });
+    }
+    authorities.delete(sessionId);
+    return workspace;
+}
+export function setOwnedSessionWorkspace(options) {
+    const { sessionManager, activeState, sessionId, workspace } = options;
+    if (!sessionId || !sessionManager.exists(sessionId))
+        return null;
+    try {
+        const stateRevision = sessionManager.setSessionWorkspace(sessionId, workspace);
+        if (activeState?.sessionId === sessionId) {
+            Object.assign(activeState, { workspace, stateRevision });
+        }
+        return workspace;
+    }
+    catch {
+        return null;
+    }
+}
+export function releaseOwnedSessionWorkspace(options) {
+    const { sessionManager, activeState, sessionId } = options;
+    if (!sessionId || !sessionManager.exists(sessionId))
+        return null;
+    const mainRoot = sessionManager.readSessionMainRoot(sessionId) ??
+        (activeState?.sessionId === sessionId ? activeState.cwd : undefined);
+    if (!mainRoot)
+        return null;
+    return setOwnedSessionWorkspace({
+        sessionManager,
+        activeState,
+        sessionId,
+        workspace: { root: mainRoot, kind: "main" },
+    });
+}

package/dist/engine/engine.d.ts

@@ -125,6 +125,7 @@ export declare class Engine {
     private lastMessages;
     private lastSessionId;
     private compactedMessagesBySession;
+    private workspaceAuthorities;
     /**
      * SIDs whose ctx-bar seed we've already emitted in this process. The seed
      * is a rough char/4 estimate; only useful before the first real
@@ -187,6 +188,7 @@ export declare class Engine {
      * writers are additionally fenced by SessionManager's persisted revision CAS.
      */
     private runInProgress;
+    private disposed;
     private agentControlStateListener?;
     private agentDirectionsDeliveredListener?;
     /** Permission update requested while runInProgress. Applied in run() finally. */
@@ -511,6 +513,8 @@ export declare class Engine {
     private persistFinalRunState;
     private persistRunProgress;
     getConfig(): EngineConfig;
+    /** Release Engine-local registrations after its owning ChatSession is replaced. */
+    dispose(): Promise<void>;
     /**
      * Config hot-reload "layer 2": merge a disk-default config patch into this
      * ALREADY-RUNNING session's `this.config`, reload settings hooks, and
@@ -593,17 +597,8 @@ export declare class Engine {
         goalId?: string;
         revision?: number;
     }): boolean;
-    /**
-     * Persist a workspace pointer through the Engine that owns the live bundle.
-     * Host-side workspace actions use this RPC-facing seam so advancing the disk
-     * revision also rebases the active run before its next progress write.
-     */
     setSessionWorkspace(sessionId: string, workspace: SessionWorkspace): SessionWorkspace | null;
-    /**
-     * Reset a session's workspace pointer back to its main root. If the session is
-     * actively running, mutate that live SessionBundle first so the run's next
-     * saveState cannot resurrect a stale worktree pointer.
-     */
+    migrateSessionMainRoot(sessionId: string, project: import("../types.js").SessionProjectBinding, mainRoot: string): SessionWorkspace;
     releaseSessionWorkspace(sessionId: string): SessionWorkspace | null;
     injectContext(sessionId: string, content: string): void;
     /**