deplyze-code 0.1.1 → 0.1.3

package/scripts/smoke.ts

@@ -0,0 +1,491 @@
+import { randomUUID } from 'crypto'
+import { spawn } from 'child_process'
+import { mkdir, mkdtemp, readFile, rm, unlink, writeFile } from 'fs/promises'
+import { tmpdir } from 'os'
+import { dirname, join } from 'path'
+import { fileURLToPath } from 'url'
+import { getSessionId, setOriginalCwd } from '../src/bootstrap/state.js'
+import peersCommand from '../src/commands/peers/index.ts'
+import { getBuiltInAgents } from '../src/tools/AgentTool/builtInAgents.ts'
+import { ListPeersTool } from '../src/tools/ListPeersTool/ListPeersTool.ts'
+import { executeAutoDream, initAutoDream } from '../src/services/autoDream/autoDream.ts'
+import {
+  AUTO_DREAM_SMOKE_ENV,
+  isAutoDreamSmokeEnabled,
+  isAutoDreamSupported,
+} from '../src/services/autoDream/config.ts'
+import { getDefaultAppState, type AppState } from '../src/state/AppStateStore.ts'
+import { ASYNC_AGENT_ALLOWED_TOOLS } from '../src/constants/tools.ts'
+import { enableConfigs } from '../src/utils/config.ts'
+import { getModelOptions } from '../src/utils/model/modelOptions.ts'
+import { getPlatform } from '../src/utils/platform.ts'
+import { getProjectDir } from '../src/utils/sessionStorage.js'
+import { buildEffectiveSystemPrompt } from '../src/utils/systemPrompt.ts'
+import { listLocalPeers, sendToUdsSocket } from '../src/utils/udsClient.ts'
+import { getUdsMessagingSocketPath, startUdsMessaging } from '../src/utils/udsMessaging.ts'
+
+type SmokePhase = 'common' | 'phase1' | 'phase2' | 'phase3'
+
+const GEMINI_API_KEY = process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY
+const ROOT = dirname(dirname(fileURLToPath(import.meta.url)))
+const MEMORY_SELECTOR_PATH = join(
+  ROOT,
+  'src',
+  'components',
+  'memory',
+  'MemoryFileSelector.tsx',
+)
+
+function stripAnsi(value: string): string {
+  return value.replace(/\u001B\[[0-9;]*[A-Za-z]/g, '')
+}
+
+function normalizePathForComparison(value: string): string {
+  const withForwardSlashes = value.replaceAll('\\', '/').toLowerCase()
+  return withForwardSlashes.replace(/^([a-z]):/, (_match, drive: string) => {
+    return `/${drive}`
+  })
+}
+
+function assert(condition: unknown, message: string): asserts condition {
+  if (!condition) {
+    throw new Error(message)
+  }
+}
+
+async function runProcess(
+  args: string[],
+  options?: {
+    env?: NodeJS.ProcessEnv
+    stdin?: string
+    timeoutMs?: number
+    cwd?: string
+    expectExitCode?: number
+  },
+): Promise<{ stdout: string; stderr: string; code: number | null }> {
+  const child = spawn(process.execPath, args, {
+    cwd: options?.cwd ?? ROOT,
+    env: options?.env ?? process.env,
+    stdio: 'pipe',
+  })
+
+  let stdout = ''
+  let stderr = ''
+  child.stdout.on('data', chunk => {
+    stdout += chunk.toString()
+  })
+  child.stderr.on('data', chunk => {
+    stderr += chunk.toString()
+  })
+
+  if (options?.stdin) {
+    child.stdin.write(options.stdin)
+  }
+  child.stdin.end()
+
+  const result = await new Promise<{
+    stdout: string
+    stderr: string
+    code: number | null
+  }>((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      child.kill()
+      reject(
+        new Error(
+          `Timed out after ${options?.timeoutMs ?? 60_000}ms: bun ${args.join(' ')}`,
+        ),
+      )
+    }, options?.timeoutMs ?? 60_000)
+
+    child.on('error', error => {
+      clearTimeout(timeout)
+      reject(error)
+    })
+
+    child.on('exit', code => {
+      clearTimeout(timeout)
+      resolve({
+        stdout: stripAnsi(stdout),
+        stderr: stripAnsi(stderr),
+        code,
+      })
+    })
+  })
+
+  if (
+    options?.expectExitCode !== undefined &&
+    result.code !== options.expectExitCode
+  ) {
+    throw new Error(
+      [
+        `Unexpected exit code ${result.code} for bun ${args.join(' ')}`,
+        result.stdout && `stdout:\n${result.stdout}`,
+        result.stderr && `stderr:\n${result.stderr}`,
+      ]
+        .filter(Boolean)
+        .join('\n\n'),
+    )
+  }
+
+  return result
+}
+
+async function launchStabilityCheck(env: NodeJS.ProcessEnv): Promise<void> {
+  const child = spawn(process.execPath, ['run', './bin/deplyze'], {
+    cwd: ROOT,
+    env,
+    stdio: 'pipe',
+  })
+
+  let stderr = ''
+  child.stderr.on('data', chunk => {
+    stderr += chunk.toString()
+  })
+
+  const exitEarly = await new Promise<{ code: number | null; signal: NodeJS.Signals | null } | null>(
+    resolve => {
+      const timer = setTimeout(() => resolve(null), 1_500)
+      child.on('exit', (code, signal) => {
+        clearTimeout(timer)
+        resolve({ code, signal })
+      })
+    },
+  )
+
+  if (exitEarly) {
+    throw new Error(
+      `Interactive launch exited early (code=${exitEarly.code}, signal=${exitEarly.signal ?? 'none'})\n${stripAnsi(stderr)}`,
+    )
+  }
+
+  child.kill()
+  await new Promise(resolve => child.on('exit', resolve))
+}
+
+async function runCommonSmoke(phase: string): Promise<void> {
+  assert(
+    GEMINI_API_KEY,
+    'GEMINI_API_KEY or GOOGLE_API_KEY must be set for live smoke tests.',
+  )
+
+  const env = {
+    ...process.env,
+    GEMINI_API_KEY,
+  }
+
+  await launchStabilityCheck(env)
+
+  const plain = await runProcess(
+    ['run', './bin/deplyze', '-p', 'Reply exactly OK.'],
+    { env, expectExitCode: 0, timeoutMs: 120_000 },
+  )
+  assert(plain.stdout.includes('OK'), 'Plain prompt smoke did not return OK.')
+
+  const bash = await runProcess(
+    [
+      'run',
+      './bin/deplyze',
+      '-p',
+      'Use Bash to print the current working directory and answer with only that path.',
+      '--allowedTools',
+      'Bash',
+      '--dangerously-skip-permissions',
+    ],
+    { env, expectExitCode: 0, timeoutMs: 120_000 },
+  )
+  const bashOut = normalizePathForComparison(bash.stdout.trim())
+  const rootPath = normalizePathForComparison(ROOT)
+  assert(
+    bashOut.includes(rootPath),
+    `Bash smoke did not include workspace path.\n${bash.stdout}`,
+  )
+
+  const smokeDir = join(ROOT, '.tmp-smoke')
+  const smokeFile = join(smokeDir, `${phase}.txt`)
+  await mkdir(smokeDir, { recursive: true })
+  await unlink(smokeFile).catch(() => {})
+  const fileWrite = await runProcess(
+    [
+      'run',
+      './bin/deplyze',
+      '-p',
+      `Use Write to create ${smokeFile} containing PHASE_OK and answer only DONE.`,
+      '--allowedTools',
+      'Write',
+      '--dangerously-skip-permissions',
+    ],
+    { env, expectExitCode: 0, timeoutMs: 120_000 },
+  )
+  assert(
+    fileWrite.stdout.includes('DONE'),
+    `File write smoke did not report DONE.\n${fileWrite.stdout}`,
+  )
+  const written = await readFile(smokeFile, 'utf8')
+  assert(written.includes('PHASE_OK'), 'File write smoke did not write PHASE_OK.')
+  await unlink(smokeFile)
+
+  enableConfigs()
+  const modelLabels = getModelOptions()
+    .map(option => option.label.toLowerCase())
+    .join('\n')
+  assert(
+    modelLabels.includes('gemini 3.1 pro') &&
+      modelLabels.includes('gemini 3 flash') &&
+      modelLabels.includes('gemini 3.1 flash-lite'),
+    `Model smoke did not surface Gemini options.\n${modelLabels}`,
+  )
+}
+
+async function runPhase1FeatureSmoke(): Promise<void> {
+  const tempDir = await mkdtemp(join(tmpdir(), 'deplyze-smoke-phase1-'))
+  const previousConfigDir = process.env.CLAUDE_CONFIG_DIR
+  const previousSmokeEnv = process.env[AUTO_DREAM_SMOKE_ENV]
+  const previousRemote = process.env.CLAUDE_CODE_REMOTE
+
+  try {
+    process.env.CLAUDE_CONFIG_DIR = join(tempDir, '.claude')
+    process.env[AUTO_DREAM_SMOKE_ENV] = '1'
+    delete process.env.CLAUDE_CODE_REMOTE
+
+    const projectDir = join(tempDir, 'project')
+    setOriginalCwd(projectDir)
+    const transcriptDir = getProjectDir(projectDir)
+    await mkdir(transcriptDir, { recursive: true })
+    await writeFile(join(transcriptDir, `${randomUUID()}.jsonl`), '')
+
+    let appState: AppState = getDefaultAppState()
+    const setAppState = (updater: (prev: AppState) => AppState) => {
+      appState = updater(appState)
+    }
+
+    initAutoDream()
+    await executeAutoDream({
+      toolUseContext: {
+        getAppState: () => appState,
+        setAppState,
+      },
+    } as never)
+
+    const [task] = Object.values(appState.tasks)
+    assert(task, 'Auto-dream smoke did not register a task.')
+    assert(task.type === 'dream', 'Auto-dream smoke registered the wrong task type.')
+    assert(task.status === 'completed', 'Auto-dream smoke task did not complete.')
+    assert(
+      task.type === 'dream' && task.turns[0]?.text.includes('smoke trigger'),
+      'Auto-dream smoke task did not record the smoke progress turn.',
+    )
+    assert(isAutoDreamSmokeEnabled(), 'Auto-dream smoke env was not recognized.')
+    assert(isAutoDreamSupported(), 'Auto-dream should be supported in the local Gemini runtime.')
+
+    const selectorSource = await readFile(MEMORY_SELECTOR_PATH, 'utf8')
+    assert(
+      !selectorSource.includes('/dream to run'),
+      'Memory selector still advertises the broken /dream path.',
+    )
+
+    await writeFile(join(transcriptDir, `${getSessionId()}.jsonl`), '')
+  } finally {
+    if (previousConfigDir === undefined) {
+      delete process.env.CLAUDE_CONFIG_DIR
+    } else {
+      process.env.CLAUDE_CONFIG_DIR = previousConfigDir
+    }
+    if (previousSmokeEnv === undefined) {
+      delete process.env[AUTO_DREAM_SMOKE_ENV]
+    } else {
+      process.env[AUTO_DREAM_SMOKE_ENV] = previousSmokeEnv
+    }
+    if (previousRemote === undefined) {
+      delete process.env.CLAUDE_CODE_REMOTE
+    } else {
+      process.env.CLAUDE_CODE_REMOTE = previousRemote
+    }
+    await rm(tempDir, { recursive: true, force: true })
+  }
+}
+
+async function runPhase2FeatureSmoke(): Promise<void> {
+  const previousCoordinatorMode = process.env.CLAUDE_CODE_COORDINATOR_MODE
+
+  try {
+    process.env.CLAUDE_CODE_COORDINATOR_MODE = '1'
+
+    const coordinatorAgents = getBuiltInAgents()
+    assert(
+      coordinatorAgents.length === 1,
+      `Coordinator mode should expose exactly one worker agent, got ${coordinatorAgents.length}.`,
+    )
+
+    const [worker] = coordinatorAgents
+    assert(worker?.agentType === 'worker', 'Coordinator worker agent is missing.')
+
+    const workerPrompt = worker.getSystemPrompt({
+      toolUseContext: { options: {} } as never,
+    })
+    assert(
+      workerPrompt.includes('worker agent operating under a coordinator'),
+      'Coordinator worker prompt did not load.',
+    )
+    assert(
+      !workerPrompt.toLowerCase().includes('claude.ai'),
+      'Coordinator worker prompt should stay provider-agnostic.',
+    )
+
+    assert(
+      worker.tools?.length === 1 && worker.tools[0] === '*',
+      'Coordinator worker should rely on the async worker tool pool.',
+    )
+    assert(
+      ASYNC_AGENT_ALLOWED_TOOLS.has('Bash') &&
+        ASYNC_AGENT_ALLOWED_TOOLS.has('Read') &&
+        ASYNC_AGENT_ALLOWED_TOOLS.has('Edit') &&
+        ASYNC_AGENT_ALLOWED_TOOLS.has('Write') &&
+        !ASYNC_AGENT_ALLOWED_TOOLS.has('Agent') &&
+        !ASYNC_AGENT_ALLOWED_TOOLS.has('SendMessage'),
+      'Coordinator worker async tool pool no longer matches the expected provider-agnostic contract.',
+    )
+
+    const prompt = buildEffectiveSystemPrompt({
+      mainThreadAgentDefinition: undefined,
+      toolUseContext: { options: {} } as never,
+      customSystemPrompt: undefined,
+      defaultSystemPrompt: ['default prompt'],
+      appendSystemPrompt: undefined,
+      overrideSystemPrompt: undefined,
+    })
+    const promptText = prompt.join('\n')
+    assert(
+      promptText.includes('You are a **coordinator**'),
+      'Coordinator system prompt did not activate under the env gate.',
+    )
+    assert(
+      promptText.includes('subagent_type `worker`'),
+      'Coordinator system prompt does not describe the worker handoff path.',
+    )
+  } finally {
+    if (previousCoordinatorMode === undefined) {
+      delete process.env.CLAUDE_CODE_COORDINATOR_MODE
+    } else {
+      process.env.CLAUDE_CODE_COORDINATOR_MODE = previousCoordinatorMode
+    }
+  }
+}
+
+async function runPhase3FeatureSmoke(): Promise<void> {
+  const tempDir = await mkdtemp(join(tmpdir(), 'deplyze-smoke-phase3-'))
+  const previousConfigDir = process.env.CLAUDE_CONFIG_DIR
+  const platform = getPlatform()
+  const holder = spawn(process.execPath, ['-e', 'setTimeout(() => {}, 30000)'], {
+    stdio: 'ignore',
+  })
+
+  try {
+    const holderPid = holder.pid
+    assert(holderPid, 'Phase 3 smoke could not create a holder process.')
+
+    process.env.CLAUDE_CONFIG_DIR = join(tempDir, '.claude')
+    const sessionsDir = join(process.env.CLAUDE_CONFIG_DIR, 'sessions')
+    await mkdir(sessionsDir, { recursive: true })
+    const sessionId = randomUUID()
+    await writeFile(
+      join(sessionsDir, `${holderPid}.json`),
+      JSON.stringify(
+        {
+          pid: holderPid,
+          sessionId,
+          cwd: ROOT,
+          startedAt: Date.now(),
+          kind: 'interactive',
+          name: 'phase3-peer',
+          status: 'idle',
+          messagingSocketPath: '/tmp/phase3-peer.sock',
+        },
+        null,
+        2,
+      ),
+    )
+
+    const peers = await listLocalPeers()
+    assert(peers.length === 1, 'Phase 3 smoke did not discover the registry peer.')
+    assert(peers[0]?.name === 'phase3-peer', 'Phase 3 smoke peer name mismatch.')
+
+    const toolResult = await ListPeersTool.call(
+      {},
+      {} as never,
+      (() => {
+        throw new Error('not used')
+      }) as never,
+      {} as never,
+    )
+    assert(
+      toolResult.data.peers[0]?.sessionId === sessionId,
+      'ListPeersTool did not return the registry peer.',
+    )
+
+    const commandModule = await peersCommand.load()
+    const commandResult = await commandModule.call('', {} as never)
+    assert(
+      commandResult.type === 'text' &&
+        commandResult.value.includes('phase3-peer') &&
+        commandResult.value.includes('transport:'),
+      '/peers did not return the expected local peer summary.',
+    )
+
+    await startUdsMessaging(join(tempDir, 'sockets', 'phase3.sock'))
+    if (platform === 'windows') {
+      assert(
+        getUdsMessagingSocketPath() === undefined,
+        'Native Windows should not advertise a live UDS socket in Phase 3.',
+      )
+      await sendToUdsSocket('/tmp/phase3-peer.sock', 'hello').then(
+        () => {
+          throw new Error('Native Windows transport should remain deferred.')
+        },
+        error => {
+          assert(
+            String(error).includes('native windows'),
+            `Unexpected Windows UDS error: ${String(error)}`,
+          )
+        },
+      )
+      assert(
+        peers[0]?.canMessage === false,
+        'Native Windows peers must remain non-messageable in Phase 3.',
+      )
+    }
+  } finally {
+    holder.kill()
+    if (previousConfigDir === undefined) {
+      delete process.env.CLAUDE_CONFIG_DIR
+    } else {
+      process.env.CLAUDE_CONFIG_DIR = previousConfigDir
+    }
+    await rm(tempDir, { recursive: true, force: true })
+  }
+}
+
+async function main(): Promise<void> {
+  const phase = (process.argv[2] ?? 'common') as SmokePhase
+
+  switch (phase) {
+    case 'common':
+      await runCommonSmoke('common')
+      break
+    case 'phase1':
+      await runCommonSmoke('phase1')
+      await runPhase1FeatureSmoke()
+      break
+    case 'phase2':
+      await runCommonSmoke('phase2')
+      await runPhase2FeatureSmoke()
+      break
+    case 'phase3':
+      await runCommonSmoke('phase3')
+      await runPhase3FeatureSmoke()
+      break
+    default:
+      throw new Error(`Unsupported smoke phase: ${phase}`)
+  }
+}
+
+await main()

package/src/QueryEngine.ts

@@ -112,9 +112,8 @@ import {
 const getCoordinatorUserContext: (
   mcpClients: ReadonlyArray<{ name: string }>,
   scratchpadDir?: string,
-) => { [k: string]: string } = feature('COORDINATOR_MODE')
-  ? require('./coordinator/coordinatorMode.js').getCoordinatorUserContext
-  : () => ({})
+) => { [k: string]: string } =
+  require('./coordinator/coordinatorMode.js').getCoordinatorUserContext
 /* eslint-enable @typescript-eslint/no-require-imports */
 
 // Dead code elimination: conditional import for snip compaction

package/src/commands/peers/index.ts

@@ -0,0 +1,50 @@
+import type { Command, LocalCommandCall } from '../../types/command.js'
+import { listLocalPeers } from '../../utils/concurrentSessions.js'
+import { getPlatform } from '../../utils/platform.js'
+
+const call: LocalCommandCall = async () => {
+  const peers = await listLocalPeers()
+  if (peers.length === 0) {
+    const platform = getPlatform()
+    const suffix =
+      platform === 'windows'
+        ? ' Native Windows live UDS transport remains deferred in this phase.'
+        : ''
+    return {
+      type: 'text',
+      value: `No local peers found.${suffix}`,
+    }
+  }
+
+  const value = peers
+    .map(peer => {
+      const header = `${peer.name ?? peer.sessionId} [${peer.kind}]`
+      const details = [
+        `session: ${peer.sessionId}`,
+        `pid: ${peer.pid}`,
+        `cwd: ${peer.cwd}`,
+        `transport: ${peer.transport}${peer.address ? ` (${peer.address})` : ''}`,
+        `messageable: ${peer.canMessage ? 'yes' : `no${peer.reason ? ` - ${peer.reason}` : ''}`}`,
+      ]
+      if (peer.status) {
+        details.splice(3, 0, `status: ${peer.status}`)
+      }
+      return [header, ...details].join('\n')
+    })
+    .join('\n\n')
+
+  return {
+    type: 'text',
+    value,
+  }
+}
+
+const peers = {
+  type: 'local',
+  name: 'peers',
+  description: 'List discoverable local peer sessions for inbox coordination',
+  supportsNonInteractive: true,
+  load: () => Promise.resolve({ call }),
+} satisfies Command
+
+export default peers