cursor-opencode-provider 0.8.0 → 0.8.3

package/dist/shell-timeout.d.ts

@@ -11,10 +11,16 @@ export type CursorShellPolicy = {
     hardTimeoutMs?: number;
     /** Immediate nohup detach for Cursor `background_shell_spawn_args`. */
     backgroundSpawn?: boolean;
+    description?: string;
+    managedCommand?: string;
+    managedJobDirectory?: string;
+    shellPath?: string;
 };
 export type CursorShellOutcome = {
     kind: "exit";
     code: number;
+} | {
+    kind: "aborted";
 } | {
     kind: "timeout";
     timeoutMs: number;
@@ -26,9 +32,27 @@ export type CursorShellOutcome = {
     workingDirectory: string;
     msToWait: number;
     reason: 1;
+    /** Managed terminal record holding the command's output. */
+    outputFile?: string;
 };
+/**
+ * Serialize OpenCode 2 shell creates onto their owning tool call. Call from
+ * `execute.before` after `prepareCursorShellArgs`, passing the hook event the
+ * host later executes. Every call arms, so an ordinary call cannot take a
+ * wrapped call's adapter; `prepareCursorShellCreate` releases the holder at
+ * its create. Only a create whose command a `create.before` hook rewrote
+ * cannot be attributed; that call keeps its own command's lane until
+ * `execute.after` or its failure.
+ */
+export declare function armCursorShellCreate(toolCallId: string, call: {
+    readonly input: unknown;
+}): Promise<void>;
+/** Release a create-before arm when the call is claimed, fails, or finishes. */
+export declare function disarmCursorShellCreate(toolCallId: string): void;
 /** Track OpenCode's configured shell from the classic config hook. */
-export declare function setCursorShellPath(shell: string | undefined): void;
+export declare function setCursorShellPath(shell: string | undefined, directory?: string): void;
+/** The executable selected by native OpenCode config, with its POSIX fallback. */
+export declare function resolveCursorShellPath(shell?: string, directory?: string): string;
 /**
  * Mirror the relevant part of OpenCode Shell.acceptable(): fish/nu are denied,
  * then POSIX falls back to bash when installed and `/bin/sh` otherwise.
@@ -61,20 +85,22 @@ export declare function buildSoftBackgroundCommand(policy: CursorShellPolicy): s
  * Residual: the detached child is not reaped by this provider after OpenCode
  * completes the tool call; cleanup is left to the user / OS.
  */
-export declare function buildBackgroundShellCommand(command: string): string;
+export declare function buildBackgroundShellCommand(command: string, shellPath?: string): string;
 /**
  * Prepare OpenCode Bash args before execution when Cursor requested wrapping.
  *
  * bash/zsh source the shell.env injector, so the original command remains in
- * OpenCode's permission/UI state. sh/dash ignore those startup variables; for
- * them, use a short `exec wrapper.sh` command that contains no user payload.
+ * OpenCode's permission/UI state. sh/dash ignore those startup variables;
+ * managed jobs expose the complete launcher and payload for host approval.
  *
  * background_shell_spawn may already contain the inline non-plugin fallback.
  * The classic hook replaces it with the original command (bash/zsh) or the
- * shorter wrapper-file command (sh/dash), avoiding duplicate execution.
+ * inline managed launcher (sh/dash), avoiding duplicate execution.
  */
 export declare function prepareCursorShellArgs(toolCallId: string, args: Record<string, unknown>, options?: {
     preferWrapperCommand?: boolean;
+    deferToShellHook?: boolean;
+    shellPath?: string;
 }): void;
 /** Restore the model-facing command in OpenCode's completed tool title. */
 export declare function cursorShellOriginalCommand(toolCallId: string): string | undefined;
@@ -86,11 +112,26 @@ export declare function releaseCursorShellEnv(toolCallId: string): void;
  */
 export declare function cursorShellEnvForCall(toolCallId: string | undefined): Record<string, string> | undefined;
 /**
- * OpenCode 2.0 `shell.create.before` has no tool-call id. Correlate the pending
- * wrap by command + working directory when possible, then fall back to the
- * original command for hosts that omit the directory.
+ * OpenCode 2.0.27 calls create.before before its permission scanner, then
+ * spawns the selected executable with [-c, command]. Preserve that command
+ * and the shell basename the scanner uses. The adapter runs only after host
+ * approval, and uses the host's selected executable for the actual payload.
+ * Sources: upstream packages/core/src/shell.ts:274-305 and
+ * packages/core/src/tool/plugin/shell.ts:125-145 at v2.0.27.
+ */
+export declare function prepareCursorShellCreate(event: {
+    command: string;
+    cwd: string;
+    shell: string;
+    env: Record<string, string | undefined>;
+}): void;
+/**
+ * Turn a stored timeout display back into OpenCode's own timeout block, so a
+ * replayed result parses as the timeout it was after its saved outcome is gone.
  */
-export declare function cursorShellEnvForCommand(command: string | undefined, workingDirectory?: string): Record<string, string> | undefined;
+export declare function restoreOpenCodeTimeout(display: string, timeoutMs: number): string;
+/** The timeout recorded for a call whose result has not been consumed yet. */
+export declare function cursorShellTimeoutMs(toolCallId: string): number | undefined;
 /**
  * Strip private wrapper sentinels / OpenCode timeout envelopes for display.
  * Does not record outcomes — use {@link captureCursorShellResult} for that.
@@ -99,7 +140,7 @@ export declare function cursorShellEnvForCommand(command: string | undefined, wo
  * a string. Non-string input is returned unchanged so the 2.0 after-hook can
  * pass structured output through safely.
  */
-export declare function sanitizeCursorShellDisplayOutput(output: string, policy?: CursorShellPolicy): string;
+export declare function sanitizeCursorShellDisplayOutput(output: string, policy?: CursorShellPolicy, capturedOutcome?: CursorShellOutcome): string;
 /** Sanitize a secondary display string (e.g. Bash `metadata.output`) for a registered call. */
 export declare function sanitizeRegisteredCursorShellOutput(toolCallId: string, output: string): string;
 /**
@@ -110,10 +151,13 @@ export declare function sanitizeRegisteredCursorShellOutput(toolCallId: string,
  * by returning it unchanged.
  */
 export declare function captureCursorShellResult(toolCallId: string, output: string, metadata?: Record<string, unknown>): string;
+/** Record the host's authoritative error status, even if its SDK drops that flag. */
+export declare function captureCursorShellFailure(toolCallId: string, error: unknown): void;
 /** Consume the structured result, with an inline fallback when no plugin hook ran. */
 export declare function consumeCursorShellResult(toolCallId: string, output: string): {
     output: string;
     outcome?: CursorShellOutcome;
+    error?: string;
 };
 /** Test/process cleanup. */
 export declare function resetCursorShellCalls(): void;