@toddzheng024/dscode-desktop 0.7.41 → 0.7.44

package/plugins/openai/oauth.mjs

@@ -0,0 +1,82 @@
+import { createHash, randomBytes } from 'node:crypto';
+import { createServer } from 'node:http';
+import { createLocalJWKSet, jwtVerify } from 'jose';
+import { LlmError } from '@deepseek-ai/dsh-llm';
+import { API, ISSUER, jsonRequest, tokenRequest } from './http.mjs';
+export const SCOPES = 'openid profile email offline_access resource.invoke chatgpt.tokens.use.direct';
+const random = () => randomBytes(32).toString('base64url');
+export function transaction(data, account, consent = false) {
+  return { state: random(), nonce: random(), verifier: random(), hostId: data.hostId, revision: data.revision,
+    clientId: account?.clientId ?? 'dynamic_agent_client', subject: account?.subject, consent };
+}
+export function authorizationUrl(tx) {
+  const params = new URLSearchParams({ client_id: tx.clientId, ext_agent_host_id: tx.hostId, response_type: 'code', redirect_uri: tx.redirectUri,
+    scope: SCOPES, resource: API, state: tx.state, nonce: tx.nonce, code_challenge_method: 'S256', code_challenge: createHash('sha256').update(tx.verifier).digest('base64url') });
+  if (tx.clientId === 'dynamic_agent_client') params.set('agent_name_hint', 'DSCODE');
+  if (tx.consent) params.set('prompt', 'consent');
+  // Deliberately omit id_token_hint: a safe fallback URL must contain no tokens.
+  return ISSUER + '/api/accounts/authorize?' + params;
+}
+export async function callbackServer(tx, { port = 0, timeoutMs = 300000, signal } = {}) {
+  let resolve, reject, timer, settled = false;
+  const result = new Promise((a,b) => { resolve = a; reject = b; }); result.catch(() => {});
+  const finish = (error, value) => {
+    if (settled) return; settled = true; clearTimeout(timer); signal?.removeEventListener('abort', cancel);
+    server.close(); server.closeAllConnections?.(); if (error) reject(error); else resolve(value);
+  };
+  const cancel = () => finish(new Error('OpenAI login cancelled'));
+  const server = createServer((req, res) => {
+    res.setHeader('content-type', 'text/plain; charset=utf-8'); res.setHeader('cache-control', 'no-store');
+    res.setHeader('referrer-policy', 'no-referrer'); res.setHeader('connection', 'close'); res.setHeader('content-security-policy', "default-src 'none'");
+    let url; try { url = new URL(req.url, 'http://127.0.0.1'); } catch { res.writeHead(400); res.end(); return; }
+    if (req.method !== 'GET' || url.pathname !== '/auth/callback') { res.writeHead(404); res.end(); return; }
+    if (url.searchParams.get('state') !== tx.state) { res.writeHead(400); res.end('Invalid state'); return; }
+    const code = url.searchParams.get('code'), clientId = url.searchParams.get('client_id') ?? tx.clientId;
+    const valid = !url.searchParams.has('error') && code && clientId !== 'dynamic_agent_client'
+      && /^[a-zA-Z0-9_-]{1,200}$/.test(clientId) && (tx.clientId === 'dynamic_agent_client' || clientId === tx.clientId);
+    res.writeHead(valid ? 200 : 400); res.end(valid ? 'Authorization received. Return to DSCODE and run /openai status.' : 'Authorization failed. Return to DSCODE.');
+    res.once('finish', () => finish(valid ? undefined : new Error('OpenAI authorization declined or invalid'), { code, clientId }));
+  });
+  server.requestTimeout = 5000; server.headersTimeout = 5000;
+  signal?.throwIfAborted();
+  await new Promise((a,b) => { server.once('error', b); server.listen(port, '127.0.0.1', a); });
+  server.on('error', () => finish(new Error('OpenAI callback failed')));
+  tx.redirectUri = `http://127.0.0.1:${server.address().port}/auth/callback`;
+  timer = setTimeout(() => finish(new Error('OpenAI login expired')), timeoutMs); timer.unref?.();
+  signal?.addEventListener('abort', cancel, { once: true }); if (signal?.aborted) cancel();
+  return { result, close: cancel, url: authorizationUrl(tx) };
+}
+export class IdentityVerifier {
+  constructor(fetcher = globalThis.fetch) { this.fetch = fetcher; }
+  async discovery() {
+    if (!this.config) {
+      const config = await jsonRequest(ISSUER + '/.well-known/openid-configuration', {}, this.fetch);
+      if (config.issuer !== ISSUER || ![config.jwks_uri, config.revocation_endpoint].every(u => typeof u === 'string' && new URL(u).origin === ISSUER)) throw new LlmError('Invalid OpenAI discovery document', 'AUTH');
+      this.config = config;
+    }
+    return this.config;
+  }
+  async verify(token, tx, { refresh = false } = {}) {
+    const config = await this.discovery();
+    for (let attempt = 0; attempt < 2; attempt++) {
+      if (!this.keys || Date.now() - this.fetched > 3600000 || attempt) { this.keys = createLocalJWKSet(await jsonRequest(config.jwks_uri, {}, this.fetch)); this.fetched = Date.now(); }
+      try {
+        const { payload } = await jwtVerify(token, this.keys, { issuer: ISSUER, audience: tx.clientId, algorithms: ['RS256', 'ES256'], requiredClaims: ['sub','exp','iat'], clockTolerance: 5 });
+        if ((!refresh && payload.nonce !== tx.nonce) || typeof payload.sub !== 'string' || !payload.sub || (tx.subject && payload.sub !== tx.subject)) throw Error('Identity mismatch');
+        return payload;
+      } catch (error) { if (error.code === 'ERR_JWKS_NO_MATCHING_KEY' && !attempt) continue; throw new LlmError('OpenAI identity validation failed', 'AUTH'); }
+    }
+  }
+}
+export function tokenFields(token, previous = {}) {
+  if (typeof token.access_token !== 'string' || !token.access_token || typeof token.refresh_token !== 'string' || !token.refresh_token
+    || String(token.token_type).toLowerCase() !== 'bearer' || !Number.isFinite(token.expires_in) || token.expires_in <= 0) throw new LlmError('OpenAI returned incomplete credentials', 'AUTH');
+  const scopes = typeof token.scope === 'string' ? token.scope.split(/\s+/) : previous.scopes;
+  if (!Array.isArray(scopes)) throw new LlmError('OpenAI did not return granted scopes', 'AUTH');
+  return { access: token.access_token, refresh: token.refresh_token, idToken: token.id_token ?? previous.idToken, expires: Date.now() + token.expires_in * 1000, scopes };
+}
+export async function exchangeCode(callback, tx, verifier, fetcher, signal) {
+  const token = await tokenRequest({ grant_type: 'authorization_code', client_id: callback.clientId, code: callback.code, code_verifier: tx.verifier, redirect_uri: tx.redirectUri }, fetcher, signal);
+  const identity = await verifier.verify(token.id_token, { ...tx, clientId: callback.clientId });
+  return { clientId: callback.clientId, subject: identity.sub, email: typeof identity.email === 'string' ? identity.email : undefined, ...tokenFields(token) };
+}

package/plugins/openai/speed.d.mts

@@ -0,0 +1,2 @@
+/** Speed display shared with the terminal; implementation lives in speed.mjs. */
+export function speedLabel(sessionId: string, modelLabel?: string): string;

package/plugins/openai/speed.mjs

@@ -0,0 +1,48 @@
+import { resolveSpeed } from './models.mjs';
+let source;
+export function setSpeedSource(next) { source = next; return () => { if (source === next) source = undefined; }; }
+export function speedLabel(sessionId, modelLabel) { return source?.(sessionId, modelLabel) ?? ''; }
+// Reuse the native command lifecycle, which the persisted session vocabulary
+// understands. Failed commands and status-only queries never select a tier.
+function selection(events) {
+  const runs = new Map(); let selected;
+  for (const event of events) {
+    if (event.type === 'command/run' && event.data.name === 'speed') {
+      const tier = event.data.args?.trim();
+      if (['standard','default','fast','priority','ultrafast'].includes(tier)) runs.set(event.data.commandId, tier === 'standard' ? 'default' : tier);
+    } else if (event.type === 'command/done' && event.data.kind === 'success' && runs.has(event.data.commandId)) {
+      selected = { tier: runs.get(event.data.commandId), seq: event.seq };
+    }
+  }
+  return selected;
+}
+export function selectedSpeed(session, fallback = 'default') {
+  return selection(session?.snapshotEvents() ?? [])?.tier ?? fallback;
+}
+export const canonicalSpeed = tier => tier === 'priority' ? 'fast' : tier;
+export function speedState(session, model, fallback = 'default') {
+  const events = session?.snapshotEvents() ?? [], selected = selection(events);
+  const requested = selected?.tier ?? fallback;
+  const used = events.findLast(e => e.type === 'assistant/message' && !e.data.interrupted
+    && e.data.message?.source?.provider === 'openai' && e.data.message.source.model === model
+    && e.data.message.source.replayState?.response?.kind === 'dscode-openai');
+  const replay = used?.data.message.source.replayState.response;
+  return { requested, actual: used && (!selected || used.seq > selected.seq) && canonicalSpeed(replay.requestedTier) === canonicalSpeed(requested) ? replay.actualTier : undefined };
+}
+export function speedCommand(service) {
+  return { name: 'speed', description: 'OpenAI service speed, independent of reasoning effort', input: { hint: '[standard|fast|ultrafast]' }, handler: async ({ agent, rawInput }) => {
+    const route = agent.session.requestHeader()?.config ?? agent.options;
+    if (route.provider !== 'openai') return { kind: 'error', text: '/speed currently applies to /provider openai.' };
+    try {
+      const model = await service.models.get(route.model);
+      const requested = String(rawInput ?? '').trim();
+      if (!requested) {
+        const state = speedState(agent.session, route.model, service.options().serviceTier);
+        return { kind: 'success', text: `Speed requested: ${state.requested}; last confirmed: ${state.actual ?? 'not yet confirmed'}. Available: ${model.tiers.map(t => t.name).join(', ')}. Fast and Ultrafast consume more usage.` };
+      }
+      if (agent.status === 'running') return { kind: 'error', text: 'Stop the current turn before changing speed.' };
+      const tier = resolveSpeed(model, requested);
+      return { kind: 'success', text: `OpenAI speed: ${canonicalSpeed(tier)}. This selection is saved for this session. Higher speeds consume more usage; /effort remains independent.` };
+    } catch (error) { return { kind: 'error', text: error.code ? error.message : 'Could not change OpenAI speed.' }; }
+  } };
+}

package/plugins/openai/store.mjs

@@ -0,0 +1,44 @@
+import { mkdirSync, openSync, closeSync, readFileSync, writeFileSync, renameSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { tryLockExclusive } from '@deepseek-ai/node-addon-system/flock';
+
+/** One stable host identity and atomic account records, serialized across Hosts. */
+export class OpenAIStore {
+  constructor(directory) { this.directory = directory; this.path = join(directory, 'accounts.json'); }
+  read() {
+    try {
+      const data = JSON.parse(readFileSync(this.path, 'utf8'));
+      if (data.version !== 1 || !Array.isArray(data.accounts) || typeof data.hostId !== 'string') throw Error();
+      return data;
+    } catch (error) {
+      if (error.code === 'ENOENT') return undefined;
+      throw new Error('Cannot read OpenAI account storage', { cause: error });
+    }
+  }
+  write(data) {
+    mkdirSync(this.directory, { recursive: true, mode: 0o700 });
+    const temp = join(this.directory, '.' + randomUUID());
+    try { writeFileSync(temp, JSON.stringify(data), { mode: 0o600, flag: 'wx' }); renameSync(temp, this.path); }
+    finally { try { unlinkSync(temp); } catch { /* renamed or not created */ } }
+  }
+  async locked(action, signal) {
+    mkdirSync(this.directory, { recursive: true, mode: 0o700 });
+    const fd = openSync(join(this.directory, '.guard'), 'a', 0o600), deadline = Date.now() + 45000;
+    try {
+      for (;;) {
+        signal?.throwIfAborted();
+        try { await tryLockExclusive(fd); break; }
+        catch (error) {
+          if (!['EAGAIN', 'EWOULDBLOCK'].includes(error.code)) throw error;
+          if (Date.now() >= deadline) throw Error('OpenAI account storage is busy; retry', { cause: error });
+          await new Promise(resolve => setTimeout(resolve, 25));
+        }
+      }
+      signal?.throwIfAborted();
+      const data = this.read() ?? { version: 1, hostId: 'urn:uuid:' + randomUUID(), mode: 'chatgpt', revision: 0, accounts: [] };
+      return await action(data);
+    } finally { closeSync(fd); }
+  }
+  initialize() { return this.locked(data => { this.write(data); return data; }); }
+}

package/plugins/openai/wire.mjs

@@ -0,0 +1,93 @@
+import { LlmError } from '@deepseek-ai/dsh-llm';
+import { serializeMessages } from '../providers/chat-messages.mjs';
+import { resolveSpeed } from './models.mjs';
+import { responseError } from './http.mjs';
+export const REPLAY_KIND = 'dscode-openai';
+export function requestBody(options, model, auth, requested, images) {
+  const input = [], system = [options.system].filter(Boolean);
+  for (const message of options.messages) {
+    if (message.role === 'system') { system.push(message.content.filter(b => b.type === 'text').map(b => b.text).join('\n')); continue; }
+    const replay = message.source?.replayState?.response;
+    if (message.role === 'assistant' && message.source?.provider === 'openai' && message.source.model === model.id && replay?.kind === REPLAY_KIND && replay.account === auth.key && Array.isArray(replay.items)) { input.push(...replay.items); continue; }
+    for (const wire of serializeMessages([message], { model: model.id, images, dialect: { provider: 'openai', reasoningContent: () => false } })) {
+      if (wire.role === 'tool') { input.push({ type: 'function_call_output', call_id: wire.tool_call_id, output: wire.content }); continue; }
+      const content = typeof wire.content === 'string' ? wire.content ? [{ type: wire.role === 'assistant' ? 'output_text' : 'input_text', text: wire.content }] : []
+        : wire.content.map(p => p.type === 'text' ? { type: 'input_text', text: p.text } : { type: 'input_image', image_url: p.image_url.url, detail: 'auto' });
+      if (content.length) input.push({ role: wire.role === 'system' ? 'developer' : wire.role, content });
+      for (const call of wire.tool_calls ?? []) input.push({ type: 'function_call', namespace: 'dscode', call_id: call.id, name: call.function.name, arguments: call.function.arguments });
+    }
+  }
+  const effort = options.reasoningEffort ?? model.defaultEffort;
+  if (effort !== undefined && !model.efforts.includes(effort)) throw new LlmError('This OpenAI model does not advertise that reasoning effort', 'UNSUPPORTED_REASONING_EFFORT');
+  const tools = (options.tools ?? []).map(t => ({ type: 'function', name: t.name, description: t.description, parameters: t.parameters, strict: false }));
+  return { model: model.id, stream: true, store: false, input, include: ['reasoning.encrypted_content'], service_tier: resolveSpeed(model, requested),
+    ...(system.length ? { instructions: system.join('\n\n') } : {}), ...(effort ? { reasoning: { effort, summary: 'auto' } } : {}),
+    ...(tools.length ? { tools: [{ type: 'namespace', name: 'dscode', description: 'DSCODE local tools', tools }] } : {}),
+    ...(auth.mode === 'api-key' ? { max_output_tokens: Math.min(options.maxTokens ?? model.maxTokens, model.maxTokens), ...(options.temperature !== undefined && !effort ? { temperature: options.temperature } : {}) } : {}) };
+}
+const usageOf = u => u && Number.isFinite(u.input_tokens) && Number.isFinite(u.output_tokens) ? {
+  inputTokens: Math.max(0, u.input_tokens - (u.input_tokens_details?.cached_tokens ?? 0)), outputTokens: u.output_tokens,
+  cacheReadTokens: u.input_tokens_details?.cached_tokens ?? 0, reasoningTokens: u.output_tokens_details?.reasoning_tokens ?? 0,
+  ...(Number.isFinite(u.total_tokens) ? { totalTokens: u.total_tokens } : {}) } : undefined;
+/** Stream visible deltas, but commit tool calls only after response.completed. */
+export async function* translate(payloads, { model, account, requested }) {
+  let completed;
+  const completedItems = new Map();
+  const started = new Map(); let nextIndex = 0;
+  for await (const raw of payloads) {
+    if (raw === '[DONE]') break;
+    let e; try { e = JSON.parse(raw); } catch { throw new LlmError('Malformed OpenAI stream', 'MALFORMED_RESPONSE'); }
+    if (e.type === 'error' || e.type === 'response.failed') throw responseError(e.response?.error?.code?.includes('usage_limit') ? 429 : 400, { error: e.error ?? e.response?.error ?? e }, e.response?.id);
+    if (e.type === 'response.incomplete') throw new LlmError('OpenAI response was incomplete; no tool calls were committed', 'INCOMPLETE_RESPONSE');
+    if (e.type === 'response.completed') { completed = e.response; continue; }
+    if (completed && /delta|output_item/.test(e.type)) throw new LlmError('OpenAI emitted content after completion', 'MALFORMED_RESPONSE');
+    if (e.type === 'response.output_item.done') {
+      if (!Number.isSafeInteger(e.output_index) || e.output_index < 0 || !e.item || typeof e.item !== 'object'
+        || completedItems.has(e.output_index) || e.item.status && e.item.status !== 'completed') throw new LlmError('Invalid completed OpenAI output item', 'MALFORMED_RESPONSE');
+      completedItems.set(e.output_index, e.item);
+      continue;
+    }
+    const kind = e.type === 'response.output_text.delta' ? 'text' : e.type === 'response.reasoning_summary_text.delta' ? 'reasoning' : undefined;
+    if (kind) {
+      const key = `${e.output_index}:${kind}`;
+      if (!started.has(key)) { const index = nextIndex++; started.set(key, index); yield { type: 'block-start', index, blockType: kind }; }
+      yield { type: kind === 'text' ? 'text-delta' : 'reasoning-delta', index: started.get(key), text: e.delta };
+    }
+  }
+  if (!completed || completed.status !== 'completed' || !Array.isArray(completed.output)) throw new LlmError('OpenAI stream ended before completion', 'TRANSPORT');
+  // The direct route may send an empty output array in the terminal envelope.
+  // In that case use fully completed items, never argument/text deltas. The
+  // response.completed gate above still controls all tool commits.
+  const itemEntries = [...completedItems].sort(([a], [b]) => a - b);
+  if (!completed.output.length && itemEntries.some(([index], position) => index !== position)) throw new LlmError('OpenAI completion omitted output items', 'MALFORMED_RESPONSE');
+  const output = completed.output.length ? completed.output : itemEntries.map(([, item]) => item), blocks = [];
+  let hasTools = false;
+  for (let i = 0; i < output.length; i++) {
+    const item = output[i]; let block;
+    if (item.type === 'message') {
+      if (item.content?.some(p => p.type === 'refusal')) throw new LlmError('OpenAI declined the response', 'CONTENT_FILTER');
+      if (!Array.isArray(item.content) || item.content.some(p => p.type !== 'output_text')) throw new LlmError('Unsupported OpenAI output content', 'UNSUPPORTED_CONTENT');
+      block = { type: 'text', text: item.content.map(p => p.text).join('') };
+    } else if (item.type === 'reasoning') block = { type: 'reasoning', text: (item.summary ?? []).map(p => p.text ?? '').join('') };
+    else if (item.type === 'function_call') {
+      if (item.namespace && item.namespace !== 'dscode') throw new LlmError('Unknown OpenAI tool namespace', 'MALFORMED_RESPONSE');
+      let args; try { args = JSON.parse(item.arguments); } catch { throw new LlmError('Invalid OpenAI tool arguments', 'MALFORMED_RESPONSE'); }
+      if (!args || typeof args !== 'object' || Array.isArray(args) || typeof item.name !== 'string' || !item.name || typeof item.call_id !== 'string' || !item.call_id) throw new LlmError('Invalid OpenAI tool call', 'MALFORMED_RESPONSE');
+      block = { type: 'tool-call', id: item.call_id, name: item.name, arguments: item.arguments }; hasTools = true;
+    } else throw new LlmError('Unsupported OpenAI output item', 'UNSUPPORTED_CONTENT');
+    const key = `${i}:${block.type}`;
+    let index = started.get(key);
+    const needsStart = index === undefined;
+    if (needsStart) index = nextIndex++;
+    blocks.push({ index, block, needsStart });
+  }
+  if (!blocks.length || !blocks.some(b => b.block.type === 'tool-call' || b.block.text)) throw new LlmError('OpenAI returned no content', 'EMPTY_RESPONSE');
+  // Validate every returned item before emitting any committed block.
+  if ([...started.values()].some(index => !blocks.some(b => b.index === index))) throw new LlmError('OpenAI completion omitted streamed content', 'MALFORMED_RESPONSE');
+  for (const { index, block, needsStart } of blocks.sort((a,b) => a.index-b.index)) {
+    if (needsStart) yield { type: 'block-start', index, blockType: block.type };
+    yield { type: 'block-end', index, block };
+  }
+  const usage = usageOf(completed.usage); if (usage) yield { type: 'usage', usage };
+  yield { type: 'finish', reason: { kind: hasTools ? 'tool-calls' : 'stop' }, replayState: { response: { kind: REPLAY_KIND, model, account, items: output, requestedTier: requested, actualTier: completed.service_tier }, blocks: blocks.sort((a,b) => a.index-b.index).map(b => ({ type: b.block.type })) } };
+}

package/plugins/providers/catalog.mjs

@@ -12,6 +12,8 @@ export const PROVIDERS = Object.freeze([
   // The OpenCode Go subscription: its chat-completions models, authorised only by an OpenCode
   // account login. `login` names the command that sets the credential up; there is no key to paste.
   { id: 'opencode-go', name: 'OpenCode Go', aliases: ['opencode-go', 'opencode', 'go'], credentialRef: 'OPENCODE_OAUTH', login: '/opencode login', defaultModel: 'kimi-k3' },
+  { id: 'antigravity', name: 'Antigravity', aliases: ['antigravity', 'google-antigravity', 'agy'], credentialRef: 'ANTIGRAVITY_OAUTH', login: '/antigravity login', defaultModel: 'gemini-3.8-flash' },
+  { id: 'openai', name: 'OpenAI / ChatGPT', aliases: ['openai', 'codex', 'chatgpt'], credentialRef: 'OPENAI_API_KEY', defaultModel: 'gpt-6.1-sol' },
 ]);
 
 // The pi-ai adapter served OpenRouter until 0.7.6, from this settings section.

package/plugins/providers/startup-commands.d.mts

@@ -0,0 +1,6 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { CommandDefinition, CommandDescriptor } from '@deepseek-ai/dsh-commands';
+/** Register a global Host command whose metadata is safe to show before a session exists. */
+export function registerStartupCommand(ctx: Context, definition: CommandDefinition): () => void;
+export function startupCommands(ctx: Context): readonly CommandDescriptor[];
+export function watchStartupCommands(ctx: Context, listener: () => void): () => void;

package/plugins/providers/startup-commands.mjs

@@ -0,0 +1,27 @@
+// Discovery for Host commands before the terminal has a receiving Agent.
+// Execution remains in the native registry; only immutable descriptors live here.
+const catalogs = new WeakMap();
+function catalog(ctx) {
+  let value = catalogs.get(ctx.root);
+  if (!value) { value = { entries: new Set(), listeners: new Set() }; catalogs.set(ctx.root, value); }
+  return value;
+}
+function notify(value) { for (const listener of value.listeners) listener(); }
+export function registerStartupCommand(ctx, definition) {
+  const unregister = ctx.commands.register(definition);
+  const value = catalog(ctx);
+  const descriptor = Object.freeze({ name: definition.name, description: definition.description,
+    ...(definition.input ? { input: Object.freeze({ ...definition.input }) } : {}) });
+  value.entries.add(descriptor); notify(value);
+  const remove = () => { if (value.entries.delete(descriptor)) notify(value); };
+  ctx.effect(() => remove);
+  return () => { remove(); unregister(); };
+}
+export function startupCommands(ctx) {
+  return [...new Map([...catalog(ctx).entries].map(d => [d.name, d])).values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+export function watchStartupCommands(ctx, listener) {
+  const value = catalog(ctx);
+  value.listeners.add(listener);
+  return () => value.listeners.delete(listener);
+}

package/vendor/persistent/index.js

@@ -1,7 +1,5 @@
+// dscode-noninteractive-bash-v1
 // dscode-shell-capture-v1
-// dscode-stdin-stall-v2
-const STDIN_STALL_MS = 5000;
-const STDIN_STALL_NOTE = "\n[Interrupted after 5s with no output: the command held the terminal without producing anything, and this tool cannot supply terminal input. Give it stdin (a heredoc, `< file` or `< /dev/null`) or use a non-interactive form.]";
 // dscode-shell-reset-v1
 import { randomUUID } from "node:crypto";
 import z from "@deepseek-ai/schemastery";
@@ -94,7 +92,7 @@ function quoteForBash(value) {
 	return `$'${value.replaceAll("\\", "\\\\").replaceAll("'", "\\'").replaceAll("\r", "\\r").replaceAll("\n", "\\n")}'`;
 }
 function wrapCommand(command, marker) {
-	return `printf '%s\\n' ${quoteForBash(marker.start)}; eval -- ${quoteForBash(command)}; __dsh_persistent_bash_status=$?; printf '%s%s\\n' ${quoteForBash(marker.end)} "$__dsh_persistent_bash_status"`;
+	return `printf '%s\\n' ${quoteForBash(marker.start)}; eval -- ${quoteForBash(command)} < /dev/null; __dsh_persistent_bash_status=$?; printf '%s%s\\n' ${quoteForBash(marker.end)} "$__dsh_persistent_bash_status"`;
 }
 function trimTrailingNewline(text) {
 	return text.replace(/(?:\r?\n)+$/, "");
@@ -267,9 +265,6 @@ async function executeCommand(ctx, shells, owner, command, config, upstream) {
 		}
 		const marker = markers();
 		const wrapped = wrapCommand(command, marker);
-		const startedAt = Date.now();
-		let stdinWaited = false;
-		let stdinStalled = false;
 		let first = true;
 		let fallback = "";
 		let fallbackTruncated = false;
@@ -312,21 +307,9 @@ async function executeCommand(ctx, shells, owner, command, config, upstream) {
 			}
 			if (captured.text.includes(marker.end)) {
 				const complete = commandOutput(captured, marker);
-				if (complete !== void 0) return renderCaptured(complete, config.maxOutputChars) + (stdinStalled ? STDIN_STALL_NOTE : "");
+				if (complete !== void 0) return renderCaptured(complete, config.maxOutputChars);
 			}
 			if (result.sessionStatus.kind === "exited") return await respondToSessionExit(ctx, shells, owner, id, result.sessionStatus, marker, fallback, fallbackTruncated, config);
-			const partial = renderCaptured(partialOutput(captured, marker, fallback, fallbackTruncated), config.maxOutputChars);
-			if (result.waitReason === "stdin_read") stdinWaited = true;
-			if (result.waitReason === "stdin_read" && partial.length > 0) return partial;
-			if (stdinWaited && partial.length === 0 && !stdinStalled && Date.now() - startedAt >= STDIN_STALL_MS) {
-				stdinStalled = true;
-				try {
-					await ctx.terminals.signal(owner, id, "SIGINT");
-				} catch (_unsignallableForeground) {
-					stdinStalled = false;
-					return partial;
-				}
-			}
 			await pause();
 		}
 	} catch (e_1) {