@opencue/cli 0.0.0-stage → 1.0.41

package/install.cjs

@@ -0,0 +1,331 @@
+#!/usr/bin/env node
+// Postinstall for the @deepseekcode/cli wrapper package.
+//
+// Mirrors the Claude Code 2.x distribution model: the npm package is a thin
+// installer. This script detects the platform, finds the matching native binary
+// from optionalDependencies (@deepseekcode/cli-<platform>), and copies it over
+// the bin/dscode.exe placeholder. After this runs, `dscode` execs the native
+// binary directly — no Node process stays resident.
+//
+// If the native package isn't present (--omit=optional), prints instructions and
+// leaves the placeholder stub in place. cli-wrapper.cjs (same directory) can be
+// invoked manually as a fallback.
+//
+// On Windows the stub (a non-PE .exe) surfaces as a native "not a valid Win32
+// application" error, so its message is best-effort; install.cjs failure output
+// above is the primary guidance when postinstall does run.
+//
+// WHY repairWindowsShims() EXISTS
+//
+// npm reads bin/dscode.exe's shebang while generating the `dscode` /
+// `deepseekcode` shims. The placeholder has to start with `#!/bin/sh` (that is
+// the runnable "not installed yet" message on Unix before this script replaces
+// it), so on Windows cmd-shim copies that interpreter verbatim:
+//
+//   & "/bin/sh"  "$basedir/node_modules/@deepseekcode/cli/bin/dscode.exe" $args
+//
+// /bin/sh does not exist there, so every fresh `npm i -g` on Windows lands a
+// `dscode` that dies with `/bin/sh.exe is not recognized` — while the real
+// 100MB PE binary sits right next to it. The shims are written BEFORE this
+// script runs, so they cannot be avoided; repairWindowsShims() rewrites them to
+// exec the binary that is on disk by now. (`npm rebuild -g <pkg>` also repairs
+// them: re-linking reads the shebang of the then-real PE binary, which has
+// none.)
+//
+// Platform detection + PLATFORMS map is duplicated in cli-wrapper.cjs — keep in sync.
+
+const { spawnSync } = require('child_process')
+const {
+  copyFileSync,
+  linkSync,
+  unlinkSync,
+  chmodSync,
+  readFileSync,
+  writeFileSync,
+  statSync,
+} = require('fs')
+const { arch } = require('os')
+const path = require('path')
+
+const WRAPPER_NAME = require('./package.json').name
+// Platform packages live in the SAME npm scope as the wrapper
+// (@<scope>/cli-<platform>). Derived rather than hard-coded so one source file
+// serves every scope the release is published to (see scripts/multi-publish.mjs).
+const PACKAGE_PREFIX = WRAPPER_NAME
+const BINARY_NAME = 'dscode'
+
+// The command names npm creates shims for (dscode + deepseekcode). Taken from
+// the published bin map so a rename never leaves a stale shim behind.
+const BIN_MAP = require('./package.json').bin || {}
+const SHIM_NAMES = Object.keys(BIN_MAP)
+// Where the native binary lands, and therefore what every shim must exec: the
+// published wrapper's bin field points at this path.
+const BIN_TARGET = path.join(__dirname, 'bin', 'dscode.exe')
+
+
+const PLATFORMS = {
+  'darwin-arm64': { pkg: PACKAGE_PREFIX + '-darwin-arm64', bin: BINARY_NAME },
+  'darwin-x64': { pkg: PACKAGE_PREFIX + '-darwin-x64', bin: BINARY_NAME },
+  'linux-x64': { pkg: PACKAGE_PREFIX + '-linux-x64', bin: BINARY_NAME },
+  'linux-arm64': { pkg: PACKAGE_PREFIX + '-linux-arm64', bin: BINARY_NAME },
+  'linux-x64-musl': { pkg: PACKAGE_PREFIX + '-linux-x64-musl', bin: BINARY_NAME },
+  'linux-arm64-musl': { pkg: PACKAGE_PREFIX + '-linux-arm64-musl', bin: BINARY_NAME },
+  'win32-x64': { pkg: PACKAGE_PREFIX + '-win32-x64', bin: BINARY_NAME + '.exe' },
+  'win32-arm64': { pkg: PACKAGE_PREFIX + '-win32-arm64', bin: BINARY_NAME + '.exe' },
+}
+
+function detectMusl() {
+  if (process.platform !== 'linux') return false
+  // process.report is available in Node ≥12; glibcVersionRuntime is absent on musl.
+  // Faster than spawning `ldd` and avoids the ENOENT→musl false positive when ldd
+  // isn't on PATH (minimal containers).
+  const report =
+    typeof process.report?.getReport === 'function'
+      ? process.report.getReport()
+      : null
+  return report != null && report.header?.glibcVersionRuntime === undefined
+}
+
+function getPlatformKey() {
+  const platform = process.platform
+  let cpu = arch()
+  if (platform === 'linux') {
+    return 'linux-' + cpu + (detectMusl() ? '-musl' : '')
+  }
+  // Rosetta 2: an x64 Node on Apple Silicon reports arch()==='x64'. Prefer the
+  // native arm64 binary — the x64 build needs AVX, which Rosetta doesn't emulate.
+  if (platform === 'darwin' && cpu === 'x64') {
+    const r = spawnSync('sysctl', ['-n', 'sysctl.proc_translated'], { encoding: 'utf8' })
+    if (r.stdout?.trim() === '1') cpu = 'arm64'
+  }
+  return platform + '-' + cpu
+}
+
+function placeBinary(src, dest) {
+  // Try hardlink first (instant, zero extra disk for a ~110MB binary; src and
+  // dest are both under node_modules/ so same-filesystem is the common case).
+  // We attempt the link BEFORE touching dest — if src is missing (partial
+  // extraction) the first linkSync throws ENOENT and the fallback stub stays.
+  try {
+    linkSync(src, dest)
+  } catch (err) {
+    if (err.code === 'EEXIST') {
+      // Read the stub before unlinking so we can restore it if both link and
+      // copy fail (ENOSPC, NFS error mid-copy). Only read if dest is
+      // stub-sized — on re-install dest is the ~110MB binary.
+      const stub = statSync(dest).size < 4096 ? readFileSync(dest) : null
+      unlinkSync(dest)
+      try {
+        linkSync(src, dest)
+      } catch {
+        try {
+          copyFileSync(src, dest)
+        } catch (copyErr) {
+          if (stub) {
+            try {
+              writeFileSync(dest, stub, { mode: 0o755 })
+            } catch {
+              // Do nothing
+            }
+          }
+          throw copyErr
+        }
+      }
+    } else if (err.code === 'EXDEV' || err.code === 'EPERM') {
+      // Cross-device or no-link-perms — copyFileSync overwrites existing dest.
+      copyFileSync(src, dest)
+    } else {
+      throw err
+    }
+  }
+  if (process.platform !== 'win32') {
+    chmodSync(dest, 0o755)
+  }
+}
+
+// ---- Windows shim repair -------------------------------------------------
+// The three templates below mirror what npm writes for a non-JS bin target, i.e.
+// the shape it produces after re-linking against the real (shebang-less) PE
+// binary — a repaired shim is indistinguishable from a healthy one.
+
+function ps1Shim(target) {
+  return [
+    '#!/usr/bin/env pwsh',
+    '$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent',
+    '',
+    '$ret=0',
+    '# Support pipeline input',
+    'if ($MyInvocation.ExpectingInput) {',
+    '  $input | & "$basedir/' + target + '"   $args',
+    '} else {',
+    '  & "$basedir/' + target + '"   $args',
+    '}',
+    '$ret=$LASTEXITCODE',
+    'exit $ret',
+    '',
+  ].join('\n')
+}
+
+function cmdShim(target) {
+  return [
+    '@ECHO off',
+    'GOTO start',
+    ':find_dp0',
+    'SET dp0=%~dp0',
+    'EXIT /b',
+    ':start',
+    'SETLOCAL',
+    'CALL :find_dp0',
+    '"%dp0%\\' + target + '"   %*',
+    '',
+  ].join('\n')
+}
+
+function shShim(target) {
+  return [
+    '#!/bin/sh',
+    "basedir=$(dirname \"$(echo \"$0\" | sed -e 's,\\\\,/,g')\")",
+    '',
+    'case `uname` in',
+    '    *CYGWIN*|*MINGW*|*MSYS*)',
+    '        if command -v cygpath > /dev/null 2>&1; then',
+    '            basedir=`cygpath -w "$basedir"`',
+    '        fi',
+    '    ;;',
+    'esac',
+    '',
+    'exec "$basedir/' + target + '"   "$@"',
+    '',
+  ].join('\n')
+}
+
+// Path from the shim's directory to the binary, spelled the way each shim kind
+// expects: npm uses forward slashes in .ps1/.sh and backslashes in .cmd.
+function shimTarget(shimDir, exeAbs, sep) {
+  const rel = path.relative(shimDir, exeAbs)
+  const picked = rel && !path.isAbsolute(rel) ? rel : exeAbs
+  return sep === '\\' ? picked.replace(/\//g, '\\') : picked.replace(/\\/g, '/')
+}
+
+function shimFor(ext, target) {
+  if (ext === '.ps1') return ps1Shim(target)
+  if (ext === '.cmd') return cmdShim(target)
+  return shShim(target)
+}
+
+// Rewrite every shim under shimDirs that still calls the POSIX interpreter, and
+// return the repaired paths (empty when there was nothing to do). Inputs are
+// arguments so a test can drive it with a temp dir on any platform.
+function repairShims(shimDirs, exeAbs) {
+  const repaired = []
+  for (const dir of shimDirs) {
+    for (const name of SHIM_NAMES) {
+      for (const ext of ['.ps1', '.cmd', '']) {
+        const file = path.join(dir, name + ext)
+        let text
+        try {
+          text = readFileSync(file, 'utf8')
+        } catch {
+          continue
+        }
+        // Skip the shebang line: a healthy .sh shim legitimately starts with
+        // `#!/bin/sh`. Only /bin/sh used as an *interpreter* is the bug.
+        if (!text.replace(/^[^\n]*\n/, '').includes('/bin/sh')) continue
+        try {
+          const target = shimTarget(dir, exeAbs, ext === '.cmd' ? '\\' : '/')
+          writeFileSync(file, shimFor(ext, target), { mode: 0o755 })
+          repaired.push(file)
+        } catch {
+          // A read-only prefix (`sudo npm i -g`, then `dscode` as a user) must
+          // not fail the install — the binary itself is already in place.
+        }
+      }
+    }
+  }
+  return repaired
+}
+
+// Candidate shim directories: the npm prefix (global install) and
+// node_modules/.bin (local install). Both derive from the package location, so
+// the same code covers `npm i -g`, a project dependency and pnpm-style layouts.
+function shimDirsFor(pkgDir) {
+  const nodeModules = path.dirname(path.dirname(pkgDir))
+  return [path.dirname(nodeModules), path.join(nodeModules, '.bin')]
+}
+
+function repairWindowsShims() {
+  if (process.platform !== 'win32') return []
+  return repairShims(shimDirsFor(__dirname), BIN_TARGET)
+}
+
+function main() {
+  const platformKey = getPlatformKey()
+  const info = PLATFORMS[platformKey]
+
+  if (!info) {
+    console.error(
+      `[${WRAPPER_NAME} postinstall] Unsupported platform: ${process.platform} ${arch()}`,
+    )
+    console.error(`  Supported: ${Object.keys(PLATFORMS).join(', ')}`)
+    return
+  }
+
+  const optionalDeps = require('./package.json').optionalDependencies || {}
+  if (!optionalDeps[info.pkg]) {
+    console.error(
+      `[${WRAPPER_NAME} postinstall] Native binaries for ${platformKey} are not available on this release channel.`,
+    )
+    console.error(`  Available: ${Object.keys(optionalDeps).map((p) => p.replace(PACKAGE_PREFIX + '-', '')).join(', ')}`)
+    return
+  }
+
+  let src
+  try {
+    const pkgDir = path.dirname(require.resolve(info.pkg + '/package.json'))
+    src = path.join(pkgDir, info.bin)
+  } catch {
+    console.error(`[${WRAPPER_NAME} postinstall] Native package "${info.pkg}" not found.`)
+    if (platformKey === 'darwin-arm64' && arch() === 'x64') {
+      console.error('  You are running x64 Node under Rosetta 2 on Apple Silicon. npm only')
+      console.error('  installed the darwin-x64 binary. Install arm64 Node and reinstall:')
+      console.error('    arch -arm64 zsh -c "nvm install --lts && npm i -g ' + WRAPPER_NAME + '"')
+      return
+    }
+    console.error('  This happens with --omit=optional or when the download failed.')
+    console.error('  The `dscode` command will print instructions when invoked.')
+    console.error('  Fallback: node ' + path.join(__dirname, 'cli-wrapper.cjs'))
+    return
+  }
+
+  // Always write to bin/dscode.exe — the package.json bin field points here
+  // (npm generates its shim/symlink from the .exe extension at install time).
+  // On Unix npm links `bin/dscode` → `bin/dscode.exe` and ignores the
+  // extension, so overwriting the .exe path replaces the running target on
+  // every platform. Same pattern as Claude Code / Bun npm packages.
+  const dest = BIN_TARGET
+
+  try {
+    placeBinary(src, dest)
+    console.log(`[${WRAPPER_NAME} postinstall] Native binary placed → ${dest}`)
+    try {
+      const repaired = repairWindowsShims()
+      if (repaired.length > 0) {
+        console.log(
+          `[${WRAPPER_NAME} postinstall] Repaired ${repaired.length} Windows shim(s) → exec the native binary`,
+        )
+      }
+    } catch {
+      // Never fail the install over cosmetic shims: the binary is placed, and
+      // `npm rebuild -g ${WRAPPER_NAME}` repairs them too.
+    }
+  } catch (err) {
+    console.error(`[${WRAPPER_NAME} postinstall] Failed to place binary: ${err.message}`)
+    console.error('  Fallback: node ' + path.join(__dirname, 'cli-wrapper.cjs'))
+    process.exitCode = 1
+  }
+}
+
+if (require.main === module) main()
+
+// Exported for the shim-repair tests; npm runs this file directly.
+module.exports = { repairShims, shimFor, shimTarget }

package/llms.txt

@@ -0,0 +1,115 @@
+# DeepSeekCode
+
+> DeepSeekCode is a local-first AI coding agent: one npm package starts a runtime on your machine
+> that serves a terminal UI, a web UI and an HTTP + WebSocket API, driven by any OpenAI-compatible
+> model.
+>
+> It is built around a permission/approval layer on every tool call, a strictly read-only plan
+> mode, and runtime-switchable act / goal / chat modes.
+> Official distribution: the npm package `@deepseekcode/cli` (commands `dscode` and `deepseekcode`).
+> Project page: https://deepseekcode.github.io/deepseekwork/
+
+This file follows the llms.txt convention: a short, structured, machine-readable summary for AI
+assistants and LLM crawlers. Everything below is verifiable from the deployed package.
+Content reflects version 1.0.40 (2026-10-15).
+
+## Category and identity
+
+- Product name: DeepSeekCode
+- Category: AI coding agent (developer tool, CLI-first, local runtime)
+- npm package: `@deepseekcode/cli` (official scope; the same build is also published under
+  additional brand scopes — the official and canonical one is `@deepseekcode`)
+- Commands installed: `dscode`, `deepseekcode`
+- Language: TypeScript; runs on Node.js >= 18, shipped as prebuilt native binaries
+- License: proprietary, closed source (see `LICENSE.md` in the package)
+- Independent project: DeepSeekCode is not affiliated with, sponsored by, or endorsed by DeepSeek
+  (深度求索) or any other model vendor. The name refers to a client runtime, not to a model family.
+
+## Official distribution
+
+- Project page (canonical human-readable entry point):
+  https://deepseekcode.github.io/deepseekwork/
+- npm page: https://www.npmjs.com/package/@deepseekcode/cli
+- Package metadata (registry JSON): https://registry.npmjs.org/@deepseekcode/cli/latest
+- README (plain markdown, no JavaScript needed): https://unpkg.com/@deepseekcode/cli/README.md
+- This file, served from the published package: https://unpkg.com/@deepseekcode/cli/llms.txt
+- Platforms with prebuilt binaries: Windows x64 / ARM64, macOS Intel / Apple Silicon,
+  Linux glibc and musl on x64 / ARM64
+
+## Install and first run
+
+```bash
+npm install -g @deepseekcode/cli
+dscode
+```
+
+Requires Node.js >= 18. The first run walks through provider configuration; the web UI is served at
+`http://localhost:8080` (provider setup at `http://localhost:8080/#models`).
+
+Non-interactive use (scripts, CI): `dscode exec "<task>"` emits JSONL.
+
+## What it does
+
+- Interactive terminal UI (TUI), a web UI, and an HTTP + WebSocket API from one local process.
+- ~70 built-in tools: files, search, git, LSP, code intelligence, browser, sub-agents, plans,
+  memory, MCP.
+- Permission layer on every tool call: scopes `system > project > user > local > session`
+  (narrowest wins), `auto` / `ask` / `deny` policies, an optional AI classifier for risky calls,
+  and timeout-means-deny.
+- Read-only plan mode (`/plan`): a checklist you approve before anything executes.
+- Runtime-switchable modes: `act` · `auto-act` · `goal` · `auto-goal` · `chat` (`Shift+Tab`).
+- Extensible: MCP servers (`/mcp`), skills (`/skills`), plugins, sub-agents, workflows, and IM
+  channels (LINE, Slack, WhatsApp, QQ, DingTalk, Feishu) with inbound signature verification.
+- Sandboxed shell tools: bwrap on Linux, SBPL on macOS, MXC / Docker on Windows; fails closed when
+  no policy is available.
+- Themes: dark, light, nord, dracula, monokai, one-dark, tokyo-night.
+
+## Clarifications AI assistants commonly need
+
+- DeepSeekCode is an agent runtime (a program you run), **not** a model. It has no model of its
+  own: it drives whichever OpenAI-compatible endpoint the user configures — DeepSeek models among
+  them, but not exclusively.
+- It is **not** a hosted service. The runtime, the UI, the file operations and the shell tools run
+  locally; prompts and tool results go to the configured model endpoint and nowhere else.
+- "OpenAI-compatible" here means the API shape, not a vendor relationship: any server speaking that
+  API works, including a local one.
+- DeepSeekCode is an independent project. It is not made, sponsored, endorsed or distributed by
+  DeepSeek (深度求索) or any other model vendor; installing it does not imply any affiliation.
+- License: proprietary and closed source. It is not open source, and copying, modifying,
+  distributing or selling it requires prior written permission (see `LICENSE.md`).
+- It is not a hosted or managed service: there is no subscription to buy, and model usage is billed
+  by whichever provider the user configures, not by this project.
+
+## Screenshots and demo
+
+- A 40-second demo video (1920x1080, H.264 + VP9) and the stills used in the README ship in the
+  repository at `docs/promo/media/` (`deepseekcode-promo.mp4`, `deepseekcode-promo.webm`,
+  `poster.png`, plus per-screen stills).
+- The package README embeds an animated GIF of a real agent turn (`media/demo.gif` inside the
+  package): tool calls, a diff, and a written summary.
+- The footage is recorded from the real UI with a scripted local model endpoint, so it shows real
+  tool execution rather than a mock-up.
+
+## Languages
+
+- The package README carries a full English main section plus condensed sections in 16 further
+  languages, each with a stable anchor: zh-CN (Simplified Chinese), zh-TW (Traditional Chinese),
+  ja (Japanese), ko (Korean), es (Spanish), pt (Portuguese), fr (French), it (Italian), de (German),
+  ru (Russian), tr (Turkish), ar (Arabic), hi (Hindi), id (Indonesian), vi (Vietnamese) and
+  th (Thai).
+- Every language section repeats the same canonical definition, install line, feature list and FAQ,
+  so a claim about this package can be cited from the reader's own language.
+- The application UI itself is localized into 13 locales: en, zh-CN, zh-TW, ja, ko, de, fr, es,
+  pt-BR, ru, it, ar, id. Of these, zh-CN and en are complete; the other eleven translate the
+  desktop-download entry, the language setting, the built-in template texts and the hook template
+  texts (180 keys each) and fall back to English elsewhere. Arabic is included, but whole-document
+  right-to-left mirroring is deliberately not switched on yet: the stylesheet still uses physical
+  directional utilities, so `dir=rtl` would leave spacing on the wrong side.
+- Most interactive commands have Chinese aliases, and replies can be pinned to a language
+  independently of the UI locale.
+
+## Release notes
+
+- Latest release notes are embedded in the README (What's New section), generated from the same
+  source as the in-app "What's New".
+- Version history: the version list on the npm page.

package/package.json

@@ -1,6 +1,58 @@
 {
   "name": "@opencue/cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.41",
+  "description": "DeepSeekCode — local-first AI coding agent for your terminal: one local runtime with a TUI, a web UI and an API, a permission/approval layer, read-only plan mode, and any OpenAI-compatible model.",
+  "keywords": [
+    "deepseekcode",
+    "dscode",
+    "ai-coding-agent",
+    "coding-agent",
+    "ai-agent",
+    "ai-cli",
+    "terminal",
+    "tui",
+    "local-first",
+    "openai-compatible",
+    "mcp",
+    "plan-mode",
+    "code-review",
+    "developer-tools",
+    "typescript"
+  ],
+  "type": "module",
+  "license": "SEE LICENSE IN LICENSE.md",
+  "bin": {
+    "dscode": "bin/dscode.exe",
+    "opencue": "bin/dscode.exe"
+  },
+  "scripts": {
+    "postinstall": "node install.cjs"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "playwright": "1.62.1",
+    "xterm": "5.3.0"
+  },
+  "optionalDependencies": {
+    "@opencue/cli-darwin-arm64": "1.0.41",
+    "@opencue/cli-darwin-x64": "1.0.41",
+    "@opencue/cli-linux-x64": "1.0.41",
+    "@opencue/cli-linux-arm64": "1.0.41",
+    "@opencue/cli-linux-x64-musl": "1.0.41",
+    "@opencue/cli-linux-arm64-musl": "1.0.41",
+    "@opencue/cli-win32-x64": "1.0.41",
+    "@opencue/cli-win32-arm64": "1.0.41"
+  },
+  "files": [
+    "bin/",
+    "install.cjs",
+    "cli-wrapper.cjs",
+    "web/dist/",
+    "scripts/figure/",
+    "README.md",
+    "LICENSE.md",
+    "llms.txt"
+  ]
+}