@cjhyy/code-shell-core 0.6.0-rc.2 → 0.6.0-rc.3

package/dist/index.d.ts

@@ -3,7 +3,7 @@
  *
  * Public API exports.
  */
-export declare const VERSION = "0.5.0-rc.2";
+export declare const VERSION = "0.6.0-rc.3";
 export type { Message, ContentBlock, ToolDefinition, ToolCall, ToolResult, RegisteredTool, TranscriptEvent, TranscriptEventType, SessionState, SessionStatus, TokenUsage, CompiledInput, PermissionDecision, PermissionMode, PermissionRule, TurnPhase, TurnResult, TerminalReason, StreamEvent, StreamCallback, LLMConfig, ClientDefaults, LLMResponse, Settings, MCPServerConfig, } from "./types.js";
 export { FrameworkError, LLMError, LLMRateLimitError, ContextLimitError, ToolError, ToolNotFoundError, ToolExecutionError, ToolTimeoutError, PermissionDeniedError, SessionError, TranscriptError, ConfigError, SandboxUnavailableError, } from "./exceptions.js";
 export { Engine, loadAgentDefinitionsForCwd } from "./engine/engine.js";

package/dist/index.js

@@ -3,7 +3,7 @@
  *
  * Public API exports.
  */
-export const VERSION = "0.5.0-rc.2";
+export const VERSION = "0.6.0-rc.3";
 // ─── Exceptions ──────────────────────────────────────────────────
 export { FrameworkError, LLMError, LLMRateLimitError, ContextLimitError, ToolError, ToolNotFoundError, ToolExecutionError, ToolTimeoutError, PermissionDeniedError, SessionError, TranscriptError, ConfigError, SandboxUnavailableError, } from "./exceptions.js";
 // ─── Engine (primary API) ────────────────────────────────────────

package/dist/protocol/server.js

@@ -461,7 +461,18 @@ export class AgentServer {
             }
             const resolve = s.pendingApprovals.get(params.requestId);
             if (!resolve) {
-                this.transport.send(createErrorResponse(req.id, ErrorCodes.InvalidParams, `No pending approval: ${params.requestId}`));
+                // Tool approvals still resolve through the interactive backend's
+                // legacy pending map; the sessionId on their envelope is UI routing
+                // metadata. Accept a session-tagged response for those requests too.
+                const legacyResolve = this.pendingApprovals.get(params.requestId);
+                if (!legacyResolve) {
+                    this.transport.send(createErrorResponse(req.id, ErrorCodes.InvalidParams, `No pending approval: ${params.requestId}`));
+                    return;
+                }
+                this.pendingApprovals.delete(params.requestId);
+                this.clearApprovalTimer(params.requestId);
+                legacyResolve(params.decision);
+                this.transport.send(createResponse(req.id, { ok: true }));
                 return;
             }
             s.pendingApprovals.delete(params.requestId);
@@ -1291,6 +1302,7 @@ export class AgentServer {
     requestApprovalFromClient(request) {
         return new Promise((resolve) => {
             const requestId = nanoid(12);
+            const sessionId = typeof request.sessionId === "string" ? request.sessionId : undefined;
             this.pendingApprovals.set(requestId, resolve);
             const timer = setTimeout(() => {
                 if (this.pendingApprovals.has(requestId)) {
@@ -1300,7 +1312,11 @@ export class AgentServer {
                 }
             }, AgentServer.APPROVAL_TIMEOUT_MS);
             this.approvalTimers.set(requestId, timer);
-            this.notify(Methods.ApprovalRequest, { requestId, request });
+            this.notify(Methods.ApprovalRequest, {
+                ...(sessionId ? { sessionId } : {}),
+                requestId,
+                request,
+            });
         });
     }
     /**

package/dist/protocol/types.d.ts

@@ -243,6 +243,8 @@ export interface AgentStreamEventNotification {
 }
 /** Server requests approval from the client (UI). */
 export interface ApprovalRequestNotification {
+    /** Originating engine session when known. */
+    sessionId?: string;
     requestId: string;
     request: ApprovalRequest;
 }

package/dist/runtime/spawn-common.js

@@ -143,8 +143,10 @@ export function resolveSpawnTarget(command, opts) {
         const wrapped = opts.sandbox.wrap(command, { cwd: opts.cwd, shell: opts.shell });
         return { file: wrapped.file, args: wrapped.args, cleanup: wrapped.cleanup };
     }
-    // No sandbox (the `off` backend / Windows): pick the shell + command-flag
-    // form for the platform instead of assuming POSIX `-c`.
+    // No sandbox configured: pick the shell + command-flag form for the
+    // platform instead of assuming POSIX `-c`. Note Bash always passes a
+    // backend (off at minimum), so it never reaches this line — the off
+    // backend's wrap() delegates to resolveShellInvocation itself.
     return resolveShellInvocation(command, opts.shell);
 }
 /**

package/dist/tool-system/builtin/cron.js

@@ -27,7 +27,14 @@ export const cronCreateToolDef = {
         "'30 8 * * 1' = 8:30am every Monday. Day-of-week: 0=Sunday..6=Saturday.\n\n" +
         "For calendar schedules, set `timezone` to the user's IANA zone (e.g. 'Asia/Shanghai', " +
         "'America/New_York'); ask the user if unknown. Set `cwd` to the project the job operates on. " +
-        "Leave `permissionLevel` as 'read-only' unless the user explicitly wants the job to modify code.",
+        "Leave `permissionLevel` as 'read-only' unless the user explicitly wants the job to modify code.\n\n" +
+        "SELF-WAKEUP / background-task safety net: you can also schedule THIS job for yourself, with no user " +
+        "request, to re-check on a long-running background task (a download, a build, a background shell/agent) " +
+        "that might hang and never signal completion. Use a short interval + `once: true` + `continueInSession: true` " +
+        "and a `prompt` that reminds you what to check, e.g. schedule '5m', once true, continueInSession true, " +
+        "prompt 'check whether the yt-dlp download finished (BashOutput/ListShells); if still running, wait again'. " +
+        "You wake back in THIS conversation with full context, inspect the task, and either finish or reschedule. " +
+        "This is the right pattern for a simple poll-until-done loop or a hang safety net — prefer it over looping Sleep.",
     inputSchema: {
         type: "object",
         properties: {
@@ -52,7 +59,8 @@ export const cronCreateToolDef = {
             once: {
                 type: "boolean",
                 description: "true = one-shot: run once at the scheduled time, then auto-delete (for 'in N minutes / " +
-                    "at <time>, do X once' reminders or tasks). Default false = recurring per `schedule`. " +
+                    "at <time>, do X once' reminders, tasks, or a self-wakeup to re-check a background task). " +
+                    "Default false = recurring per `schedule`. " +
                     "A one-shot still uses `schedule` for its time: interval '10m' = 10 minutes from now; " +
                     "cron '0 7 25 6 *' = once at 07:00 on June 25.",
             },

package/dist/tool-system/builtin/sleep.js

@@ -6,6 +6,11 @@ export const sleepToolDef = {
     description: "Pause execution for a brief, deterministic wait (e.g. letting a just-started service settle for a few seconds). " +
         "Do NOT use Sleep to poll for or wait on background work (background shells, async sub-agents, video generation): " +
         "the system wakes you automatically when that work completes — just end your turn instead of looping Sleep. " +
+        "If you want a safety net in case a background task hangs and never signals completion, do NOT loop Sleep either — " +
+        "instead end your turn and schedule a one-shot self-wakeup with CronCreate " +
+        "({ schedule: '5m', once: true, continueInSession: true, permissionLevel: 'read-only', " +
+        "prompt: 'check whether <that task> finished; if still running, wait again' }). " +
+        "That returns control to you at the interval without burning a turn spinning. " +
         "Maximum duration is 300 seconds (5 minutes).",
     inputSchema: {
         type: "object",

package/dist/tool-system/executor.js

@@ -274,7 +274,7 @@ export class ToolExecutor {
         // the hook and the user together have decided.
         if (hookResult.decision === "ask") {
             const reason = hookResult.messages?.join("\n") ?? undefined;
-            const approved = await this.permission.handleAsk(call.toolName, call.args, reason);
+            const approved = await this.permission.handleAsk(call.toolName, call.args, reason, { sessionId: this.toolCtx?.sessionId });
             if (!approved) {
                 return {
                     id: call.id,
@@ -347,7 +347,9 @@ export class ToolExecutor {
             }
             if (decision === "ask") {
                 const reason = permHook.messages?.join("\n");
-                const approved = await this.permission.handleAsk(call.toolName, call.args, reason);
+                const approved = await this.permission.handleAsk(call.toolName, call.args, reason, {
+                    sessionId: this.toolCtx?.sessionId,
+                });
                 if (!approved) {
                     return {
                         id: call.id,

package/dist/tool-system/permission.d.ts

@@ -130,7 +130,9 @@ export declare class PermissionClassifier {
     reconfigure(mode: PermissionMode, approvalBackend: ApprovalBackend, rules?: PermissionRule[]): void;
     getMode(): PermissionMode;
     classify(toolName: string, args: Record<string, unknown>): PermissionDecision;
-    handleAsk(toolName: string, args: Record<string, unknown>, reason?: string): Promise<boolean>;
+    handleAsk(toolName: string, args: Record<string, unknown>, reason?: string, opts?: {
+        sessionId?: string;
+    }): Promise<boolean>;
     /** Get denial warning message if the model keeps getting denied. */
     getDenialWarning(toolName: string): string | undefined;
     private matchesRule;

package/dist/tool-system/permission.js

@@ -861,7 +861,7 @@ export class PermissionClassifier {
                 return "ask";
         }
     }
-    async handleAsk(toolName, args, reason) {
+    async handleAsk(toolName, args, reason, opts) {
         if (this.defaultMode === "dontAsk") {
             this.log.info("permission.auto_deny", {
                 cat: "permission",
@@ -900,6 +900,7 @@ export class PermissionClassifier {
                 ? `${baseDescription}\n\nReason (from pre_tool_use hook): ${reason}`
                 : baseDescription;
             result = await this.approvalBackend.requestApproval({
+                ...(opts?.sessionId ? { sessionId: opts.sessionId } : {}),
                 toolName,
                 args,
                 description,

package/dist/tool-system/sandbox/off.js

@@ -1,8 +1,12 @@
+import { resolveShellInvocation } from "../../runtime/spawn-common.js";
 export function createOffBackend() {
     return {
         name: "off",
         wrap(command, opts) {
-            return { file: opts.shell, args: ["-c", command] };
+            // Platform-aware flag: cmd.exe takes /c, PowerShell -Command, POSIX -c.
+            // Bash always passes a backend (off at minimum), so resolveSpawnTarget's
+            // no-sandbox fallback never covers this path — wrap() must handle it.
+            return resolveShellInvocation(command, opts.shell);
         },
     };
 }

package/dist/types.d.ts

@@ -229,6 +229,8 @@ export interface PermissionRule {
     reason?: string;
 }
 export interface ApprovalRequest {
+    /** Originating engine session. Hosts use this only to route the prompt UI. */
+    sessionId?: string;
     toolName: string;
     args: Record<string, unknown>;
     description: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cjhyy/code-shell-core",
-  "version": "0.6.0-rc.2",
+  "version": "0.6.0-rc.3",
   "description": "Core engine for code-shell — agent orchestration, tool execution, hooks, protocol. UI-agnostic.",
   "type": "module",
   "main": "./dist/index.js",