dsh-claude-compat 0.3.0 → 0.7.0

package/scripts/dsh-restart.sh

@@ -0,0 +1,107 @@
+#!/usr/bin/env bash
+# dsh-restart.sh — restart the DSH Web GUI safely, with an optional
+# terminal-bash prompt patch.
+#
+# What it does:
+#   1. (optional, --no-patch to skip) Patch the dsh-terminal-bash plugin's
+#      hardcoded "dsh> " prompt so DSH's own placeholder prompt is honored.
+#      Idempotent: skips when already patched. Re-run after every npx/npm
+#      refresh of DSH (the cache overwrite reverts the patch).
+#   2. Stop any running `dsh web` (graceful wait, up to 10s).
+#   3. Start `dsh web` in the background (nohup), log to a temp file.
+#   4. Wait until http://127.0.0.1:3080 responds (up to 30s); on timeout
+#      print the last 20 log lines and exit 1.
+#
+# Requires: bash, curl. Works with a global `dsh`, an nvm-installed `dsh`,
+# or the npx cache layout (`~/.npm/_npx/*/node_modules/.bin/dsh`).
+set -euo pipefail
+
+PORT="${DSH_RESTART_PORT:-3080}"
+PATCH=1
+for arg in "$@"; do
+  case "$arg" in
+    --no-patch) PATCH=0 ;;
+    -h|--help) sed -n '2,16p' "$0"; exit 0 ;;
+    *) echo "unknown arg: $arg (see --help)" >&2; exit 2 ;;
+  esac
+done
+
+# ── 1. terminal-bash prompt patch (idempotent) ───────────────────────────────
+if [ "$PATCH" = 1 ]; then
+  OLD_PROMPT='const CONTROLLED_PROMPT = "dsh> ";'
+  NEW_PROMPT='const CONTROLLED_PROMPT = "__DSH_PERSISTENT_BASH_PROMPT__ ";'
+  OLD_LEN='Math.max(0, 6 - this.promptTail.length)'
+  NEW_LEN='Math.max(0, CONTROLLED_PROMPT.length + 1 - this.promptTail.length)'
+
+  # Find every installed copy of dsh-terminal-bash: npx cache + any global
+  # node_modules reachable from `dsh`'s real location.
+  CANDIDATES="$(ls "$HOME"/.npm/_npx/*/node_modules/@deepseek-ai/dsh-terminal-bash/lib/index.js 2>/dev/null || true)"
+  DSH_ON_PATH="$(command -v dsh || true)"
+  if [ -n "$DSH_ON_PATH" ]; then
+    REAL="$(readlink -f "$DSH_ON_PATH" 2>/dev/null || echo "$DSH_ON_PATH")"
+    ROOT="$(dirname "$(dirname "$(dirname "$(dirname "$REAL")")")")"
+    [ -f "$ROOT/@deepseek-ai/dsh-terminal-bash/lib/index.js" ] && CANDIDATES="$CANDIDATES
+$ROOT/@deepseek-ai/dsh-terminal-bash/lib/index.js"
+  fi
+
+  if [ -z "$CANDIDATES" ]; then
+    echo "[fix] no dsh-terminal-bash installation found; skipping patch"
+  else
+    for FILE in $CANDIDATES; do
+      if grep -qF "$NEW_PROMPT" "$FILE" && grep -qF "$NEW_LEN" "$FILE"; then
+        echo "[fix] already patched: $FILE"
+        continue
+      fi
+      echo "[fix] patching: $FILE"
+      if sed -i.bak -e "s|$OLD_PROMPT|$NEW_PROMPT|" -e "s|$OLD_LEN|$NEW_LEN|" "$FILE" 2>/dev/null \
+         || sed -i '' -e "s|$OLD_PROMPT|$NEW_PROMPT|" -e "s|$OLD_LEN|$NEW_LEN|" "$FILE"; then
+        rm -f "$FILE.bak"
+        grep -qF "$NEW_PROMPT" "$FILE" && grep -qF "$NEW_LEN" "$FILE" \
+          || { echo "[fix] patch failed on $FILE"; exit 1; }
+      else
+        echo "[fix] cannot write $FILE (permissions?); skipping"; continue
+      fi
+    done
+  fi
+fi
+
+# ── 2. stop running dsh web ──────────────────────────────────────────────────
+echo "[restart] stopping dsh web"
+pkill -f "dsh web" 2>/dev/null || true
+for _ in $(seq 1 20); do pgrep -f "dsh web" >/dev/null || break; sleep 0.5; done
+if pgrep -f "dsh web" >/dev/null; then
+  echo "[restart] dsh web did not stop; last resort SIGKILL"
+  pkill -9 -f "dsh web" 2>/dev/null || true
+  sleep 1
+  pgrep -f "dsh web" >/dev/null && { echo "[restart] cannot stop dsh web"; exit 1; }
+fi
+
+# ── 3. locate the dsh binary ─────────────────────────────────────────────────
+DSH_BIN="$(command -v dsh || true)"
+if [ -z "$DSH_BIN" ]; then
+  # newest npx cache entry first (npm exec resolves to the same one)
+  DSH_BIN="$(ls -t "$HOME"/.npm/_npx/*/node_modules/.bin/dsh 2>/dev/null | head -1 || true)"
+fi
+if [ -z "$DSH_BIN" ]; then
+  echo "[restart] no dsh binary found (PATH or npx cache). Install with: npm install -g @deepseek-ai/dsh" >&2
+  exit 1
+fi
+echo "[restart] using: $DSH_BIN"
+
+# ── 4. start + health-check ──────────────────────────────────────────────────
+LOG="$(mktemp -t dsh-web-restart)"
+echo "[restart] starting dsh web on :$PORT"
+nohup "$DSH_BIN" web >"$LOG" 2>&1 &
+PID=$!
+echo "[restart] pid=$PID log=$LOG"
+for _ in $(seq 1 30); do
+  if curl -sf -o /dev/null "http://127.0.0.1:$PORT"; then
+    echo "[restart] http://127.0.0.1:$PORT is up ✅"
+    exit 0
+  fi
+  kill -0 "$PID" 2>/dev/null || break
+  sleep 1
+done
+echo "[restart] failed; last log lines:"
+tail -20 "$LOG"
+exit 1

package/scripts/zstd-compat.mjs

@@ -0,0 +1,19 @@
+// zstd-compat.mjs — compress strings with the `zstd` binary via stdin.
+// (macOS: `brew install zstd`; most Linux CI images and the DSH runtime
+// environment already ship it — DSH itself shell-outs to zstd for its own
+// session logs.)
+import { execFileSync } from 'node:child_process';
+
+export function zstdSync(text) {
+  return execFileSync('zstd', ['-3', '-T0', '-q', '-'], {
+    input: text,
+    maxBuffer: 1 << 28,
+    stdio: ['pipe', 'pipe', 'inherit'],
+  });
+}
+
+// DSH session logs require the first zstd frame to hold exactly the header
+// line (assertZstdHeaderFrame); events must be in separate frames.
+export function zstdFramesSync(...texts) {
+  return Buffer.concat(texts.map((t) => zstdSync(t)));
+}

package/src/agents.js

@@ -0,0 +1,77 @@
+// dsh-claude-compat: .claude/agents/*.md compatibility. DSH has no markdown
+// subagent-definition format, so each agent file is surfaced as a DSH *skill*
+// candidate: the frontmatter name (or filename stem) becomes the skill name
+// (model- and user-invocable, so `/agent-name` works), the description doubles
+// as whenToUse, and get() prefixes the body with an explicit subagent-delegation
+// instruction. Project .claude/agents wins over ~/.claude/agents by name via
+// the provider's rank (50 < 700) plus the shared dedupe flow.
+
+import { join } from 'node:path';
+import { isSkillName } from '@deepseek-ai/dsh-skill';
+import {
+  readTextSafe,
+  stringField,
+  parseFrontmatter,
+  pathExists,
+} from './lib.js';
+
+const AGENT_HEADER = 'Agent delegation: use the subagent/background-agent capability with this persona and instructions.';
+
+// Discover agent candidates from one agents dir (flat: *.md). Returns DSH skill
+// candidates in the same shape as discoverSkills/discoverCommands so the
+// registry's dedupe treats them uniformly.
+export async function discoverAgents(rootDir, providerName, source, rank) {
+  const out = [];
+  if (!(await pathExists(rootDir))) return out;
+  let entries;
+  try {
+    const { readdir } = await import('node:fs/promises');
+    entries = await readdir(rootDir, { withFileTypes: true, encoding: 'utf8' });
+  } catch { return out; }
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith('.md')) continue;
+    const path = join(rootDir, entry.name);
+    const raw = await readTextSafe(path);
+    if (raw === undefined) continue;
+    const parsed = parseFrontmatter(raw);
+    const data = parsed?.data ?? {};
+    const stem = entry.name.slice(0, -3);
+    let name = stringField(data, 'name');
+    if (name === undefined || !isSkillName(name)) name = stem;
+    if (!isSkillName(name)) continue; // non-kebab names rejected by registry anyway
+    const description = stringField(data, 'description')
+      ?? firstLine(parsed?.body ?? raw, 100);
+    const tools = stringField(data, 'tools');
+    out.push({
+      name,
+      description,
+      whenToUse: description,
+      invocation: { modelInvocable: true, userInvocable: true },
+      provider: providerName,
+      source,
+      rank,
+      locator: { path, directory: rootDir },
+      resourceBase: { kind: 'directory', path: rootDir },
+      path,
+      agentTools: tools,
+    });
+  }
+  return out;
+}
+
+function firstLine(body, max) {
+  if (typeof body !== 'string') return undefined;
+  const line = body.split('\n').find((l) => l.trim() !== '') ?? '';
+  const trimmed = line.trim();
+  if (trimmed === '') return undefined;
+  return trimmed.length > max ? `${trimmed.slice(0, max)}…` : trimmed;
+}
+
+// Render the content the skill tool returns for an agent-backed candidate.
+export function renderAgentContent(candidate, body) {
+  const lines = [AGENT_HEADER];
+  if (candidate.agentTools !== undefined) lines.push(`Tools: ${candidate.agentTools}`);
+  lines.push('');
+  lines.push(body);
+  return lines.join('\n');
+}

package/src/cc-resume-skill.mjs

@@ -0,0 +1,35 @@
+// Skill body for /cc-resume — instructs the model to drive scripts/cc-resume.mjs.
+export const CC_RESUME_SKILL_BODY = `# Claude Code Session Resume
+
+List and import Claude Code conversation sessions into DSH. Imported sessions
+appear in the DSH session list (refresh the GUI) with full user/assistant/tool
+history and can be resumed like any native session.
+
+## Commands
+Run from the session's working directory (or pass \`--cwd <dir>\`):
+
+1. **List** Claude sessions for the current project:
+   \`\`\`bash
+   node <plugin-root>/scripts/cc-resume.mjs list --limit 20
+   \`\`\`
+   Output: one line per session — imported marker (\`*\`), id, date, message
+   count, first-user-text preview. Pick the \`sessionId\` the user wants.
+
+2. **Import** a session:
+   \`\`\`bash
+   node <plugin-root>/scripts/cc-resume.mjs import <sessionId>
+   \`\`\`
+   Options: \`--limit-turns N\` imports only the last N turns (useful for huge
+   sessions), \`--cwd <dir>\` overrides the project directory.
+
+3. Tell the user: refresh the DSH GUI session list and open the session titled
+   \`cc: <preview>\`, or the imported id can be resumed directly.
+
+## Behavior notes
+- Imports are main-thread only (Claude sidechain/subagent messages skipped).
+- Thinking blocks are dropped (DSH reasoning is stream-based; replaying
+  reconstructed reasoning would corrupt the log).
+- Re-importing the same session is idempotent (same target, events rewritten).
+- The imported conversation is static history — continuing it starts a fresh
+  DSH turn flow on top of that context.
+- Requires the \`zstd\` binary on PATH (macOS: \`brew install zstd\`).`;

package/src/hooks.js

@@ -0,0 +1,275 @@
+// dsh-claude-compat: Claude Code hooks subset (PreToolUse / PostToolUse /
+// UserPromptSubmit) bridged onto DSH's tools/pre-execute, tools/post-execute,
+// and agent/pre-step waterfalls.
+//
+// Hooks are read from <projectRoot>/.claude/settings.json (and ~/.claude/
+// settings.json; project wins on duplicate command strings). Commands run via
+// /bin/sh -c with a Claude-style JSON payload on stdin. Decisions follow Claude
+// Code semantics (exit code 2 = deny/block, hookSpecificOutput override,
+// timeouts allowed-through with a warning).
+
+import { execFile } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { createUserMessage } from '@deepseek-ai/dsh-llm';
+import {
+  findProjectRootSync,
+  resolveUserClaudeDir,
+} from './lib.js';
+
+// Compile a Claude Code hook matcher ("Bash", "Bash|Edit", ".*") into a
+// predicate. Exact names match exactly; `*` / `.*` are wildcards; `|`
+// alternates.
+export function compileMatcher(matcher) {
+  if (typeof matcher !== 'string') return () => false;
+  const trimmed = matcher.trim();
+  if (trimmed === '' || trimmed === '*' || trimmed === '.*') return () => true;
+  try {
+    const pattern = trimmed
+      .split('|')
+      .map((part) => part.trim().split('*').join('.*'))
+      .join('|');
+    const re = new RegExp(`^(?:${pattern})$`);
+    return (name) => re.test(name);
+  } catch {
+    return () => false;
+  }
+}
+
+// ----- payloads ---------------------------------------------------------------
+
+function preToolPayload(exec) {
+  return JSON.stringify({
+    session_id: String(exec.callId),
+    tool_name: exec.name,
+    tool_input: exec.arguments ?? {},
+  });
+}
+
+function postToolPayload(exec, result) {
+  return JSON.stringify({
+    tool_name: exec.name,
+    tool_input: exec.arguments ?? {},
+    tool_response: result,
+  });
+}
+
+function promptPayload(agent) {
+  let prompt = '';
+  const events = agent.session?.events ?? {};
+  for (const event of Object.values(events)) {
+    const data = event?.data;
+    if (event?.type?.endsWith('user/message') && typeof data?.content === 'string') {
+      prompt = data.content;
+    }
+  }
+  return JSON.stringify({ prompt });
+}
+
+// ----- decision mapping (pure, exported for tests) -----------------------------
+
+// PreToolUse: exit 0 → allow; exit 2 → deny (stdout reason); other codes →
+// allow with warning. stdout JSON {"hookSpecificOutput": {...permissionDecision}}
+// overrides: "deny" → deny, "ask" → ask (best effort).
+export function mapPreHookOutput(exitCode, stdout, { warn = console.warn } = {}) {
+  if (exitCode === 0) {
+    const specific = tryHookJson(stdout)?.hookSpecificOutput;
+    if (specific?.permissionDecision === 'deny') {
+      return { kind: 'deny', reason: String(specific.permissionDecisionReason ?? fallbackReason(stdout)) };
+    }
+    if (specific?.permissionDecision === 'ask') {
+      return { kind: 'ask', reason: String(specific.permissionDecisionReason ?? 'hook requests approval') };
+    }
+    return { kind: 'allow' };
+  }
+  if (exitCode === 2) {
+    return { kind: 'deny', reason: fallbackReason(stdout) };
+  }
+  warn(`dsh-claude-compat: PreToolUse hook exited with code ${exitCode}, allowing`);
+  return { kind: 'allow' };
+}
+
+// PostToolUse: exit 2 → block (stdout feedback); exit 0 with JSON stdout
+// carrying an "additionalContext" string → accept with that context as an
+// additional user message; anything else → accept, stdout log-only.
+export function mapPostHookOutput(exitCode, stdout, { warn = console.warn } = {}) {
+  if (exitCode === 2) {
+    return { kind: 'block', feedback: [{ type: 'text', text: fallbackReason(stdout) }] };
+  }
+  if (exitCode !== 0) {
+    warn(`dsh-claude-compat: PostToolUse hook exited with code ${exitCode}, accepting`);
+    return { kind: 'accept' };
+  }
+  const trimmed = stdout.trim();
+  if (trimmed === '') return { kind: 'accept' };
+  const additional = tryHookJson(stdout)?.additionalContext;
+  if (typeof additional === 'string' && additional.length > 0) {
+    return {
+      kind: 'accept',
+      additionalContexts: [createUserMessage({
+        content: [{ type: 'text', text: additional }],
+        source: { kind: 'claude-compat', form: 'hook-context' },
+      })],
+    };
+  }
+  console.log(`dsh-claude-compat: PostToolUse hook stdout (logged, not injected): ${trimmed}`);
+  return { kind: 'accept' };
+}
+
+function fallbackReason(stdout) {
+  const trimmed = stdout.trim();
+  return trimmed !== '' ? trimmed : 'blocked by hook';
+}
+
+function tryHookJson(stdout) {
+  const s = stdout.trim();
+  if (s === '') return undefined;
+  try { return JSON.parse(s); } catch { return undefined; }
+}
+
+// ----- runner ---------------------------------------------------------------
+
+function runHookCommand(command, stdin, { timeoutMs = 60_000 } = {}) {
+  return new Promise((resolve) => {
+    let stdout = '';
+    let settled = false;
+    const child = execFile('/bin/sh', ['-c', command], {
+      maxBuffer: 4 * 1024 * 1024,
+    });
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      child.kill('SIGKILL');
+      console.warn(`dsh-claude-compat: hook timed out after ${timeoutMs}ms, killed: ${command}`);
+      resolve({ exitCode: 1, stdout }); // treat as non-2, allow-through
+    }, timeoutMs);
+    child.stdout.on('data', (chunk) => { stdout += chunk; });
+    child.stderr.on('data', (chunk) => { stdout += chunk; }); // surface stderr in feedback
+    child.on('error', () => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      console.warn(`dsh-claude-compat: hook command failed to start: ${command}`);
+      resolve({ exitCode: 1, stdout });
+    });
+    child.on('close', (code) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve({ exitCode: code ?? 1, stdout });
+    });
+    child.stdin.on('error', () => {});
+    child.stdin.end(stdin);
+  });
+}
+
+// ----- settings loading ------------------------------------------------------
+
+const EVENTS = { PreToolUse: 'pre-tool-use', PostToolUse: 'post-tool-use', UserPromptSubmit: 'user-prompt-submit' };
+
+// Combined hooks map. Project .claude/settings.json is applied LAST so it wins
+// same (event, matcher, command) keys against ~/.claude/settings.json.
+export function loadHookSettings(config) {
+  const combined = {};
+  applySettingsFile(combined, join(resolveUserClaudeDir(config.userClaudeDir), 'settings.json'));
+  const projectRoot = findProjectRootSync(process.cwd(), config.projectRootMarkers);
+  if (projectRoot !== undefined) {
+    applySettingsFile(combined, join(projectRoot, '.claude', 'settings.json'));
+  }
+  return combined;
+}
+
+function applySettingsFile(combined, path) {
+  let raw;
+  try { raw = readFileSync(path, 'utf8'); } catch { return; }
+  let parsed;
+  try { parsed = JSON.parse(raw); } catch {
+    console.warn(`dsh-claude-compat: unparseable settings.json: ${path}`);
+    return;
+  }
+  const hooks = parsed?.hooks;
+  if (typeof hooks !== 'object' || hooks === null || Array.isArray(hooks)) return;
+  for (const [eventName, entries] of Object.entries(hooks)) {
+    const event = EVENTS[eventName];
+    if (event === undefined || !Array.isArray(entries)) continue;
+    for (const entry of entries) {
+      if (typeof entry !== 'object' || entry === null) continue;
+      const matcher = typeof entry.matcher === 'string' ? entry.matcher : '.*';
+      const commands = Array.isArray(entry.hooks)
+        ? entry.hooks
+            .filter((h) => typeof h === 'object' && h !== null && typeof h.command === 'string')
+            .map((h) => h.command)
+        : [];
+      for (const command of commands) {
+        combined[`${event}\u0000${matcher}\u0000${command}`] = { event, matcher, command };
+      }
+    }
+  }
+}
+
+// ----- listeners -------------------------------------------------------------
+
+export function registerHooks(ctx, config) {
+  const settings = loadHookSettings(config);
+  const matching = (hooks, name) =>
+    hooks.filter((h) => compileMatcher(h.matcher)(name));
+
+  const pre = Object.values(settings).filter((h) => h.event === 'pre-tool-use');
+  if (pre.length > 0) {
+    ctx.on('tools/pre-execute', async (exec) => {
+      for (const hook of matching(pre, exec.name)) {
+        const payload = preToolPayload(exec);
+        const run = await runHookCommand(hook.command, payload, { timeoutMs: config.hooksTimeoutMs ?? 60_000 });
+        const decision = mapPreHookOutput(run.exitCode, run.stdout);
+        if (decision.kind !== 'allow') return decision;
+      }
+      return { kind: 'allow' };
+    });
+  }
+
+  const post = Object.values(settings).filter((h) => h.event === 'post-tool-use');
+  if (post.length > 0) {
+    ctx.on('tools/post-execute', async (exec, result) => {
+      let accept;
+      for (const hook of matching(post, exec.name)) {
+        const payload = postToolPayload(exec, result);
+        const run = await runHookCommand(hook.command, payload, { timeoutMs: config.hooksTimeoutMs ?? 60_000 });
+        const decision = mapPostHookOutput(run.exitCode, run.stdout);
+        if (decision.kind === 'block') return decision;
+        if (decision.additionalContexts !== undefined) accept = decision;
+      }
+      return accept ?? { kind: 'accept' };
+    });
+  }
+
+  const prompt = Object.values(settings).filter((h) => h.event === 'user-prompt-submit');
+  if (prompt.length > 0) {
+    ctx.on('agent/pre-step', async ({ agent, messages }, next) => {
+      const decision = await next();
+      if (decision.kind !== 'enter') return decision;
+      // First enter of the turn: the DSH loop hands the step the user claims,
+      // which is where Claude Code would have fired UserPromptSubmit. Hook
+      // output becomes an extra user message appended after the claimed ones.
+      const extra = await runPromptHooks(prompt, agent, config);
+      if (extra === undefined) return decision;
+      return { kind: 'enter', messages: decision.messages.concat(extra) };
+    });
+  }
+}
+
+async function runPromptHooks(hooks, agent, config) {
+  const timeoutMs = Math.min(config.hooksTimeoutMs ?? 60_000, 10_000); // never block the loop longer than 10s
+  const payload = promptPayload(agent);
+  const extra = [];
+  for (const hook of hooks) {
+    const run = await runHookCommand(hook.command, payload, { timeoutMs });
+    if (run.exitCode !== 0) continue; // non-zero: skip, never block a prompt
+    const text = run.stdout.trim();
+    if (text === '') continue;
+    extra.push(createUserMessage({
+      content: [{ type: 'text', text }],
+      source: { kind: 'claude-compat', form: 'hook-context' },
+    }));
+  }
+  return extra.length > 0 ? extra : undefined;
+}