@anionex/dsh-computer-use 0.3.1 → 0.3.3

package/src/confirmations.ts

@@ -48,7 +48,7 @@ export class ComputerConfirmationManager {
     agent: Agent,
     app: ComputerAppIdentity,
     request: ComputerConfirmRequest,
-    callId: import('@deepseek-ai/dsh-llm').CallId | undefined,
+    callId: import('@deepseek-ai/dsh-tools').ToolRunContext['callId'] | undefined,
     signal: AbortSignal,
   ): Promise<ComputerConfirmation> {
     if (approvalPolicy(this.ctx, agent) === 'never') {

package/src/exposure.ts

@@ -5,7 +5,7 @@ import type { ContentBlock } from '@deepseek-ai/dsh-llm'
 import type { Session } from '@deepseek-ai/dsh-session'
 import { defineTool, type ToolDefinition } from '@deepseek-ai/dsh-tools'
 import type { Context } from '@deepseek-ai/cordis'
-import { COMPUTER_USE_SKILL_CONTENT, COMPUTER_USE_SKILL_NAME } from './skill.ts'
+import { COMPUTER_USE_SKILL_CONTENT, COMPUTER_USE_SKILL_NAME, COMPUTER_USE_SKILL_NAMES } from './skill.ts'
 
 /** One global bootstrap retained until the current Agent loads the Skill. */
 export const COMPUTER_USE_ACTIVATE = 'computer_use_activate'
@@ -60,7 +60,7 @@ function adHocOcrCommand(value: unknown): boolean {
 }
 
 function isSkillArguments(value: unknown): boolean {
-  return isRecord(value) && value.name === COMPUTER_USE_SKILL_NAME
+  return isRecord(value) && COMPUTER_USE_SKILL_NAMES.has(value.name as string)
 }
 
 function nativeSkillCall(raw: string): boolean {
@@ -76,18 +76,32 @@ function containsSkillContent(blocks: readonly unknown[]): boolean {
 
 function isSkillResult(value: unknown): boolean {
   return isRecord(value)
-    && value.name === COMPUTER_USE_SKILL_NAME
+    && COMPUTER_USE_SKILL_NAMES.has(value.name as string)
     && value.content === COMPUTER_USE_SKILL_CONTENT
 }
 
+/**
+ * Session event types carrying one PTC (`run_code`) sub-dispatch.
+ *
+ * DSH 0.1.5 renamed the append site from `tool/code-dispatch` to
+ * `tool/ptc-dispatch` (`dsh-tools`) with an identical payload, and its session
+ * format migration renames replayed legacy events to the new name, so a log
+ * can legitimately carry either. Both are accepted: a pre-0.1.5 host only ever
+ * appends the old name, a 0.1.5 host only the new one.
+ */
+const PTC_DISPATCH_EVENT_TYPES: ReadonlySet<string> = new Set(['tool/ptc-dispatch', 'tool/code-dispatch'])
+
 /** Whether durable Session history proves that the bundled Skill was loaded. */
 export function hasLoadedComputerUseSkill(session: Session): boolean {
   const nativeCalls = new Set<string>()
-  for (const event of session.events) {
+  const events = typeof (session as any).snapshotEvents === 'function'
+    ? (session as any).snapshotEvents()
+    : (session as unknown as { events?: readonly import('@deepseek-ai/dsh-session').SessionEvent[] }).events ?? []
+  for (const event of events) {
     if (event.type === 'user/message') {
       const source = event.data.source
       if (source.kind === 'skill-invocation'
-        && source.name === COMPUTER_USE_SKILL_NAME
+        && COMPUTER_USE_SKILL_NAMES.has(source.name)
         && containsSkillContent(event.data.content)) return true
       continue
     }
@@ -103,7 +117,7 @@ export function hasLoadedComputerUseSkill(session: Session): boolean {
         && containsSkillContent(block.content)) return true
       continue
     }
-    if (event.type === 'tool/code-dispatch'
+    if (PTC_DISPATCH_EVENT_TYPES.has(event.type)
       && event.data.name === 'skill'
       && event.data.isError === false
       && isSkillArguments(event.data.arguments)

package/src/index.ts

@@ -8,7 +8,7 @@ import type {} from '@deepseek-ai/dsh-tools'
 import { Config, type ComputerUseConfig } from './config.ts'
 import { ComputerUseExposure } from './exposure.ts'
 import { MacOSComputerUseProvider } from './providers/macos.ts'
-import { COMPUTER_USE_SKILL } from './skill.ts'
+import { COMPUTER_USE_SKILL, LEGACY_COMPUTER_USE_SKILL } from './skill.ts'
 import { createComputerUseTools } from './tools.ts'
 import { installComputerUseWeb } from './web.ts'
 
@@ -22,14 +22,17 @@ export function installComputerUseConsumer(ctx: Context): () => void {
   const exposure = new ComputerUseExposure(ctx, () => createComputerUseTools(ctx.computerUse))
   let activation: (() => void) | undefined
   let skill: (() => void) | undefined
+  let legacySkill: (() => void) | undefined
   let exposureDispose: (() => void) | undefined
   try {
     activation = ctx.tools.register(exposure.activationTool)
     skill = ctx.skills.register(COMPUTER_USE_SKILL)
+    legacySkill = ctx.skills.register(LEGACY_COMPUTER_USE_SKILL)
     exposureDispose = exposure.install()
     installComputerUseWeb(ctx)
   } catch (error) {
     exposureDispose?.()
+    legacySkill?.()
     skill?.()
     activation?.()
     throw error
@@ -37,6 +40,7 @@ export function installComputerUseConsumer(ctx: Context): () => void {
   return () => {
     exposureDispose?.()
     activation?.()
+    legacySkill?.()
     skill?.()
   }
 }

package/src/leases.ts

@@ -2,7 +2,8 @@
 
 import { z } from 'zod'
 import type { Agent } from '@deepseek-ai/dsh-agent'
-import type { CallId } from '@deepseek-ai/dsh-llm'
+import type { ToolRunContext } from '@deepseek-ai/dsh-tools'
+type CallId = ToolRunContext['callId']
 import type { SessionEvent, SessionHeader, SessionId } from '@deepseek-ai/dsh-session'
 import { defineDomain, domainTable } from '@deepseek-ai/dsh-storage-domain'
 import type { KvTable } from '@deepseek-ai/dsh-storage-domain'
@@ -185,7 +186,10 @@ export class ComputerLeaseManager {
     signal: AbortSignal,
   ): Promise<ComputerLeaseSource> {
     await this.prepareStorage()
-    const turn = currentTurn(agent.session.events)
+    const sessionEvents = typeof (agent.session as any).snapshotEvents === 'function'
+      ? (agent.session as any).snapshotEvents()
+      : (agent.session as unknown as { events?: readonly SessionEvent[] }).events ?? []
+    const turn = currentTurn(sessionEvents)
     if (turn === undefined) {
       throw new ComputerUseError('COMPUTER_PERMISSION_REQUIRED', `${scope} access for ${app.name} must be requested inside an open Agent turn`)
     }

package/src/providers/macos.ts

@@ -21,6 +21,7 @@ import type {
 import {
   Config,
   COMPUTER_USE_SETTINGS_NAMESPACE,
+  readComputerUseConfig,
   resolveConfig,
   type ComputerUseConfig,
   type ResolvedComputerUseConfig,
@@ -253,21 +254,26 @@ export class MacOSComputerUseProvider extends ComputerUseService {
   static inject = ['subprocess', 'approval', 'settings', 'sessions', 'agents']
   static Config = Config
 
-  private readonly settings
-
   constructor(ctx: Context, config: ComputerUseConfig = {}) {
-    const settings = ctx.settings.register(COMPUTER_USE_SETTINGS_NAMESPACE, Config, {
-      base: config,
-      applies: 'live',
-      validate: (value) => { resolveConfig(value) },
-    })
-    const resolved = resolveConfig(settings.get())
+    const legacySettings = ctx.settings as typeof ctx.settings & {
+      register?: (ns: typeof COMPUTER_USE_SETTINGS_NAMESPACE, schema: typeof Config, options: object) => {
+        get(): ComputerUseConfig
+        watch(listener: (value: ComputerUseConfig) => Promise<void>): () => void
+      }
+    }
+    const settings = typeof legacySettings.register === 'function'
+      ? legacySettings.register(COMPUTER_USE_SETTINGS_NAMESPACE, Config, {
+          base: config,
+          applies: 'live',
+          validate: (value: ComputerUseConfig) => { resolveConfig(value) },
+        })
+      : undefined
+    const resolved = resolveConfig(settings?.get() ?? readComputerUseConfig(config))
     super(ctx, createBackend(ctx, resolved), resolved)
-    this.settings = settings
     if (process.platform !== 'darwin') {
       ctx.logger.warn('dsh-computer-use: supports macOS only; Computer Use Tools are disabled on %s', process.platform)
     }
-    ctx.effect(() => this.settings.watch(async (next) => {
+    const reconfigure = async (next: ComputerUseConfig): Promise<void> => {
       const candidate = resolveConfig(next)
       const backend = createBackend(ctx, candidate)
       try {
@@ -276,7 +282,21 @@ export class MacOSComputerUseProvider extends ComputerUseService {
         await backend.dispose()
         throw error
       }
-    }), 'dsh-computer-use: Settings watch')
+    }
+    if (settings) {
+      ctx.effect(() => settings.watch(reconfigure), 'dsh-computer-use: Settings watch')
+    } else {
+      // DSH 0.1.7 projects Settings from Config and commits volatile fields in
+      // place. The Loader emits this event after its references have changed.
+      ctx.effect(() => {
+        const onVolatileUpdate = ctx.on as unknown as (name: string, listener: () => void) => () => void
+        return onVolatileUpdate.call(ctx, 'loader/volatile-update', () => {
+          void reconfigure(readComputerUseConfig(config)).catch(error => {
+            ctx.logger.warn('dsh-computer-use: live config update failed: %s', error)
+          })
+        })
+      }, 'dsh-computer-use: Loader volatile update')
+    }
     ctx.effect(() => ctx.on('agent/disposed', ({ agent }) => { this.releaseAgent(agent) }), 'dsh-computer-use: Agent cleanup')
   }
 

package/src/skill.ts

@@ -2,8 +2,14 @@
 
 import type { SkillRegistration } from '@deepseek-ai/dsh-skill'
 
-/** Stable Skill name used by progressive exposure and durable restore. */
-export const COMPUTER_USE_SKILL_NAME = 'computer-use'
+/** Namespaced entry avoids collisions with filesystem Skills in Agent presets. */
+export const COMPUTER_USE_SKILL_NAME = 'dsh-computer-use'
+/** Existing sessions and slash-command workflows continue to recognize this entry. */
+export const LEGACY_COMPUTER_USE_SKILL_NAME = 'computer-use'
+export const COMPUTER_USE_SKILL_NAMES: ReadonlySet<string> = new Set([
+  COMPUTER_USE_SKILL_NAME,
+  LEGACY_COMPUTER_USE_SKILL_NAME,
+])
 
 /** Complete model-visible operating and confirmation workflow. */
 export const COMPUTER_USE_SKILL_CONTENT = `# DSH Computer Use
@@ -127,3 +133,9 @@ export const COMPUTER_USE_SKILL: SkillRegistration = {
   source: 'runtime',
   content: COMPUTER_USE_SKILL_CONTENT,
 }
+
+/** Compatibility alias for existing Sessions; preset Skills may shadow it. */
+export const LEGACY_COMPUTER_USE_SKILL: SkillRegistration = {
+  ...COMPUTER_USE_SKILL,
+  name: LEGACY_COMPUTER_USE_SKILL_NAME,
+}

package/src/tools.ts

@@ -1,7 +1,8 @@
 /** Focused model-facing Computer Use Tool definitions. */
 
+import type { JsonValue } from '@deepseek-ai/dsh-util-values'
 import { createUserMessage, type ContentBlock } from '@deepseek-ai/dsh-llm'
-import { defineTool, type JsonValue, type ToolDefinition, type ToolRunContext, type ValueSchemaSpec } from '@deepseek-ai/dsh-tools'
+import { defineTool, type ToolDefinition, type ToolRunContext, type ValueSchemaSpec } from '@deepseek-ai/dsh-tools'
 import {
   ComputerConfirmationToken,
   ComputerObservationId,
@@ -38,7 +39,7 @@ function deferVisionHandoff(exec: ToolRunContext, artifact: ComputerArtifact | u
         'Do not inspect OCR executables or use bash, tesseract, screencapture, or an ad hoc Swift/Python OCR implementation.',
       ].join(' '),
     }],
-    source: { kind: 'plugin', plugin: 'dsh-computer-use' },
+    source: { kind: 'tool', callId: exec.callId },
   }))
 }
 

package/src/types.ts

@@ -2,7 +2,8 @@
 
 import type { Agent } from '@deepseek-ai/dsh-agent'
 import type { Branded } from '@deepseek-ai/dsh-brand'
-import type { CallId } from '@deepseek-ai/dsh-llm'
+import type { ToolRunContext } from '@deepseek-ai/dsh-tools'
+type CallId = ToolRunContext['callId']
 
 /** Opaque identifier for one immutable observed UI state. */
 export type ComputerObservationId = Branded<'ComputerObservationId'>

package/src/web.ts

@@ -6,6 +6,7 @@ import { SettingsConflictError, type SettingsDescriptor } from '@deepseek-ai/dsh
 import type {} from '@deepseek-ai/dsh-host-webserver'
 import {
   COMPUTER_USE_SETTINGS_NAMESPACE,
+  resolveConfig,
   type ComputerUseConfig,
 } from './config.ts'
 import type { ComputerUseStatus } from './types.ts'
@@ -59,11 +60,17 @@ function requestError(res: ServerResponse, status: number, code: string, message
   responseJson(res, status, { ok: false, error: { code, message } })
 }
 
-function sameOriginPost(req: IncomingMessage): boolean {
+function sameOriginPost(req: IncomingMessage, authorizeUnmarkedPost?: (req: IncomingMessage) => boolean): boolean {
   const fetchSite = req.headers['sec-fetch-site']
   if (fetchSite === 'cross-site') return false
   const origin = req.headers.origin
-  if (origin === undefined) return fetchSite === 'same-origin' || fetchSite === 'same-site' || fetchSite === 'none'
+  if (origin === undefined) {
+    if (fetchSite === 'same-origin' || fetchSite === 'same-site' || fetchSite === 'none') return true
+    // Desktop strips browser origin metadata before forwarding, but injects a
+    // Host-issued signed cookie. Verify it through Connection's own fence;
+    // mere Cookie header presence is not authentication.
+    return fetchSite === undefined && authorizeUnmarkedPost?.(req) === true
+  }
   const host = req.headers.host
   if (host === undefined) return false
   try {
@@ -106,9 +113,27 @@ function publicMessage(error: unknown): string {
   return error instanceof Error ? error.message.slice(0, 1000) : String(error).slice(0, 1000)
 }
 
+/**
+ * Whether one thrown value is the Settings provider's optimistic-concurrency
+ * conflict. The provider — not this module — throws it, so a second copy of
+ * `SettingsConflictError` (plugin-local versus host-local install) makes
+ * `instanceof` alone unreliable. Both the 0.1.5 and the older class carry the
+ * stable machine code `"SETTINGS_CONFLICT"`, which is checked first-class;
+ * `instanceof` stays as an equivalent additional branch.
+ */
+function isSettingsConflict(error: unknown): boolean {
+  if (error instanceof SettingsConflictError) return true
+  return typeof error === 'object'
+    && error !== null
+    && (error as { code?: unknown }).code === 'SETTINGS_CONFLICT'
+}
+
 /** Same-origin backend used by the optional client Settings section. */
 export class ComputerUseWebBackend {
-  constructor(private readonly ctx: Context) {}
+  constructor(
+    private readonly ctx: Context,
+    private readonly authorizeUnmarkedPost?: (req: IncomingMessage) => boolean,
+  ) {}
 
   /** Current browser-safe Settings and health state. */
   snapshot(): ComputerUseSettingsSnapshot {
@@ -139,7 +164,7 @@ export class ComputerUseWebBackend {
       requestError(res, 405, 'method-not-allowed', 'Use GET or POST')
       return
     }
-    if (!sameOriginPost(req)) {
+    if (!sameOriginPost(req, this.authorizeUnmarkedPost)) {
       requestError(res, 403, 'origin-rejected', 'The request must originate from this DSH Web application')
       return
     }
@@ -152,6 +177,7 @@ export class ComputerUseWebBackend {
     try {
       if (parsed.action === 'save') {
         if (!this.ctx.settings.writable) throw new Error('settings provider is read-only')
+        resolveConfig(parsed.value)
         await this.ctx.settings.replace(COMPUTER_USE_SETTINGS_NAMESPACE, parsed.value as object, parsed.expectedRevision)
       } else if (parsed.action === 'health') {
         await this.ctx.computerUse.health(AbortSignal.timeout(30000))
@@ -160,7 +186,7 @@ export class ComputerUseWebBackend {
       }
       responseJson(res, 200, { ok: true, value: this.snapshot() })
     } catch (error) {
-      const conflict = error instanceof SettingsConflictError
+      const conflict = isSettingsConflict(error)
       this.ctx.logger.warn('dsh-computer-use Web action=%s failed: %s', parsed.action, publicMessage(error))
       requestError(res, conflict ? 409 : 400, conflict ? 'settings-conflict' : 'action-failed', publicMessage(error))
     }
@@ -169,8 +195,12 @@ export class ComputerUseWebBackend {
 
 /** Attach the optional route when a Web host is present. */
 export function installComputerUseWeb(ctx: Context): void {
-  const backend = new ComputerUseWebBackend(ctx)
-  ctx.inject(['webServer'], (webCtx) => {
+  ctx.inject(['webServer', 'connection'], (webCtx) => {
+    const connection = (webCtx as Context & {
+      connection?: { requestRejection?: (req: IncomingMessage) => 401 | 403 | undefined }
+    }).connection
+    const backend = new ComputerUseWebBackend(webCtx, (req) =>
+      typeof connection?.requestRejection === 'function' && connection.requestRejection(req) === undefined)
     webCtx.effect(() => webCtx.webServer.register({
       kind: 'exact',
       path: COMPUTER_USE_SETTINGS_ROUTE,