@dashclaw/cli 0.7.3 → 0.7.6

package/lib/claude/install.js

@@ -47,6 +47,12 @@ const HOOK_FILES = [
   'dashclaw_stop.py',
   'dashclaw_code_session_reporter.py',
 ];
+// Shipped when present in the bundle, skipped otherwise — a newer CLI must
+// keep installing against an older hosted bundle. enforcement_liveness_probe
+// (v8.2) is not wired as a hook here (the CLI does not install the
+// SessionStart digest that auto-spawns it), but travels with the hooks so
+// `python .claude/hooks/enforcement_liveness_probe.py` works out of the box.
+const OPTIONAL_HOOK_FILES = ['enforcement_liveness_probe.py'];
 const HOOK_INTEL_DIR = 'dashclaw_agent_intel';
 const HOOKS_BUNDLE_PATH = '/downloads/dashclaw-claude-code-hooks.zip';
 
@@ -136,6 +142,10 @@ function copyHooksFromRepo(hooksSrc, hooksDst) {
     if (!existsSync(sp)) throw new Error(`Required hook script missing: ${sp}`);
     copyFileSync(sp, join(hooksDst, name));
   }
+  for (const name of OPTIONAL_HOOK_FILES) {
+    const sp = join(hooksSrc, name);
+    if (existsSync(sp)) copyFileSync(sp, join(hooksDst, name));
+  }
   const intelSrc = join(hooksSrc, HOOK_INTEL_DIR);
   if (!existsSync(intelSrc) || !statSync(intelSrc).isDirectory()) {
     throw new Error(`Required intel module missing: ${intelSrc}`);

package/lib/up/db.js

@@ -17,23 +17,83 @@
 // on resume so a working install never silently moves.
 
 import { join } from 'node:path';
-import { existsSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { existsSync, rmSync, writeFileSync } from 'node:fs';
 import { execFileSync, spawnSync } from 'node:child_process';
 
 // Keep this in sync with the "embedded-postgres" version in cli/package.json.
 const EMBEDDED_PG_VERSION = 'embedded-postgres@18.4.0-beta.17';
 
+// Force a UTF-8 cluster regardless of host locale. Without this, initdb on
+// Windows inherits the OS locale (e.g. English_United States.1252) and
+// creates a WIN1252-encoded database — DashClaw's migration SQL is UTF-8 and
+// statements containing characters with no WIN1252 equivalent hard-fail with
+// 22P05, leaving a partial schema (observed live in Windows Sandbox).
+const INITDB_FLAGS = ['--encoding=UTF8', '--no-locale'];
+
 // Windows exit status 0xC0000135 (STATUS_DLL_NOT_FOUND). The embedded
 // Postgres binaries link against the Microsoft Visual C++ runtime, which a
 // fresh Windows install (and Windows Sandbox) does not ship — initdb dies at
 // exec with this code and EMPTY stderr, which reads as pure noise to a
 // first-run user.
 const STATUS_DLL_NOT_FOUND = '3221225781';
+const VC_REDIST_URL = 'https://aka.ms/vs/17/release/vc_redist.x64.exe';
 const VC_REDIST_HINT =
   'Embedded Postgres needs the Microsoft Visual C++ runtime, which this Windows machine does not have. '
-  + 'Install it once from https://aka.ms/vs/17/release/vc_redist.x64.exe (or `winget install Microsoft.VCRedist.2015+.x64`), '
+  + `Install it once from ${VC_REDIST_URL} (or \`winget install Microsoft.VCRedist.2015+.x64\`), `
   + 'then re-run `npx dashclaw up`. Alternatively retry with --db docker or --db url.';
 
+// Redistributable installer exit codes that mean the runtime is (or already
+// was) in place: 0 = installed, 1638 = a newer version is already installed,
+// 3010 = installed, reboot pending (the DLLs are on disk and loadable now).
+const VC_REDIST_OK_EXIT_CODES = new Set([0, 1638, 3010]);
+
+/**
+ * Downloads and silently installs the Microsoft Visual C++ redistributable so
+ * `npx dashclaw up` stays one command on a fresh Windows machine. Elevation
+ * goes through `Start-Process -Verb RunAs`: an already-elevated shell runs it
+ * directly, a standard shell surfaces the Windows UAC consent dialog — that
+ * dialog IS the user's approval for the system-wide install. Throws (with the
+ * manual remediation appended) when the download or install fails; the caller
+ * re-checks the DLLs afterwards as the authoritative success signal.
+ */
+export async function installVcRedist({
+  logger = console,
+  fetchFn = fetch,
+  spawn = spawnSync,
+  downloadDir = tmpdir(),
+} = {}) {
+  logger.error(
+    '[..] Embedded Postgres needs the Microsoft Visual C++ runtime — installing it now '
+    + '(one-time, ~25 MB from microsoft.com; Windows may show an admin consent prompt) ...',
+  );
+  const exePath = join(downloadDir, 'dashclaw-vc_redist.x64.exe');
+  let res;
+  try {
+    res = await fetchFn(VC_REDIST_URL);
+  } catch (e) {
+    throw new Error(`VC++ runtime download failed (${e.message}). ${VC_REDIST_HINT}`);
+  }
+  if (!res.ok) {
+    throw new Error(`VC++ runtime download failed (HTTP ${res.status}). ${VC_REDIST_HINT}`);
+  }
+  writeFileSync(exePath, Buffer.from(await res.arrayBuffer()));
+  const psPath = exePath.replace(/'/g, "''");
+  const script =
+    `$p = Start-Process -FilePath '${psPath}' -ArgumentList '/install','/quiet','/norestart' -Verb RunAs -Wait -PassThru; `
+    + 'exit $p.ExitCode';
+  const run = spawn('powershell', ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-Command', script], { stdio: 'ignore' });
+  if (run.error) {
+    throw new Error(`VC++ runtime install could not start (${run.error.message}). ${VC_REDIST_HINT}`);
+  }
+  if (!VC_REDIST_OK_EXIT_CODES.has(run.status)) {
+    throw new Error(
+      `VC++ runtime installer exited with code ${run.status} (declined admin prompt, or install failure). ${VC_REDIST_HINT}`,
+    );
+  }
+  logger.error('[ok] Microsoft Visual C++ runtime installed.');
+}
+
 /**
  * True on Windows machines missing the VC++ runtime DLLs the embedded
  * Postgres binaries need. Checked BEFORE the embedded attempt so the failure
@@ -51,13 +111,33 @@ export function missingVcRuntime({ platform = process.platform, exists = existsS
  * the preflight passed (a different DLL may be the missing one).
  */
 export function embeddedFailureMessage(err) {
-  const base = `Embedded Postgres (${EMBEDDED_PG_VERSION}) failed: ${err.message}`;
-  if (String(err.message).includes(STATUS_DLL_NOT_FOUND)) {
+  // embedded-postgres rejects with NO value when the postgres process exits
+  // before it is ready (its start() does `reject()` bare) — the real reason is
+  // in the log lines it already printed. Guard, or this helper itself crashes
+  // with "Cannot read properties of undefined" and eats the actual error
+  // (observed live in Windows Sandbox).
+  const detail = err?.message
+    ?? 'the Postgres process exited before it was ready — the reason is in the log lines above';
+  const base = `Embedded Postgres (${EMBEDDED_PG_VERSION}) failed: ${detail}`;
+  if (String(detail).includes(STATUS_DLL_NOT_FOUND)) {
     return `${base} — this exit code means a required system DLL is missing. ${VC_REDIST_HINT}`;
   }
   return `${base}. Retry with --db docker or --db url.`;
 }
 
+/**
+ * Extra embedded-postgres options when running as root on POSIX (the fresh
+ * root-VPS case, caught live by the first `drill:fresh-linux --as-root` run):
+ * postgres refuses to run as root, and embedded-postgres's escape hatch is
+ * `createPostgresUser: true` (it provisions a `postgres` system user and runs
+ * the cluster as that user). No-op everywhere else — including Windows, where
+ * the elevated-token case is handled by the pg_ctl lifecycle instead.
+ */
+export function rootPostgresOptions({ platform = process.platform, getuid = process.getuid } = {}) {
+  if (platform === 'win32' || typeof getuid !== 'function') return {};
+  return getuid() === 0 ? { createPostgresUser: true } : {};
+}
+
 export const DEFAULT_DB_PORT = 5433;
 // Scan window when the preferred port is taken: preferred+1 .. preferred+10.
 const PORT_SCAN_SPAN = 10;
@@ -91,7 +171,7 @@ export function dockerAvailableSync() {
  * @param {Function}    [opts.promptFn] - async (message) => string
  * @returns {Promise<'docker'|'embedded'|'url'>}
  */
-export async function chooseDbMode({ flagDb, dockerAvailable, yes = false, promptFn }) {
+export async function chooseDbMode({ flagDb, dockerAvailable, yes = false, promptFn, logger = console }) {
   if (flagDb) return flagDb;
   if (yes) return dockerAvailable ? 'docker' : 'embedded';
 
@@ -104,7 +184,12 @@ export async function chooseDbMode({ flagDb, dockerAvailable, yes = false, promp
     '  3. I have a postgresql:// URL',
   ];
   const def = dockerAvailable ? '1' : '2';
-  const answer = (await promptFn(`${lines.join('\n')}\nChoice [${def}]: `)).trim() || def;
+  // The menu is printed OUTSIDE the readline prompt: on Windows, readline
+  // re-renders multi-line prompts on input events, so the whole menu was
+  // echoed twice (observed live in Windows Sandbox). Only the one-line
+  // "Choice" question goes through promptFn.
+  logger.error(lines.join('\n'));
+  const answer = (await promptFn(`Choice [${def}]: `)).trim() || def;
   return { 1: 'docker', 2: 'embedded', 3: 'url' }[answer] ?? (dockerAvailable ? 'docker' : 'embedded');
 }
 
@@ -284,7 +369,7 @@ async function dockerProvision({ preferredPort, ops, isFree, logger }) {
 export async function provisionDatabase({
   mode, baseDir, promptFn, savedDatabaseUrl,
   dockerOps = realDockerOps, isFree = isPortFree, waitForDbPort = waitForPort, logger = console,
-  checkVcRuntime = missingVcRuntime,
+  checkVcRuntime = missingVcRuntime, installVc = installVcRedist,
 }) {
   let preferredPort = DEFAULT_DB_PORT;
   if (savedDatabaseUrl) {
@@ -305,11 +390,24 @@ export async function provisionDatabase({
 
   // mode === 'embedded'
   if (checkVcRuntime()) {
-    throw new Error(VC_REDIST_HINT);
+    // Fresh Windows machines (and Windows Sandbox) don't ship the VC++
+    // runtime the Postgres binaries link against. Install it in-flow instead
+    // of failing with homework — `dashclaw up` promises ONE command.
+    await installVc({ logger });
+    if (checkVcRuntime()) {
+      throw new Error(`The VC++ runtime installer finished but the runtime DLLs are still missing. ${VC_REDIST_HINT}`);
+    }
+  }
+  const pgDir = join(baseDir, 'pg');
+  if (process.platform === 'win32') {
+    // postgres.exe hard-refuses an elevated (admin) token — the norm in
+    // Windows Sandbox and admin terminals. pg_ctl creates the restricted
+    // token PostgreSQL requires, so on Windows the server lifecycle goes
+    // through pg_ctl instead of embedded-postgres spawning postgres directly.
+    return provisionEmbeddedWindows({ baseDir, pgDir, preferredPort, isFree, logger });
   }
   const port = await pickDbPort({ preferred: preferredPort, isFree, logger });
   const { default: EmbeddedPostgres } = await import('embedded-postgres');
-  const pgDir = join(baseDir, 'pg');
   // Record whether the data dir existed BEFORE this run.
   // Only clean up on failure when WE created it (a pre-existing dir means
   // a working prior install whose data we must not delete).
@@ -323,9 +421,14 @@ export async function provisionDatabase({
     password: localDb.password,
     port,
     persistent: true,
+    initdbFlags: INITDB_FLAGS,
+    ...rootPostgresOptions(),
   });
   try {
-    await pg.initialise();
+    // initdb refuses a non-empty data dir, so only initialise a cluster that
+    // does not exist yet (PG_VERSION marks an initialised cluster) — without
+    // this, every resumed `up` with an embedded DB fails at re-init.
+    if (!clusterInitialised(pgDir)) await pg.initialise();
     await pg.start();
   } catch (e) {
     if (!dirPreExisted) {
@@ -338,6 +441,122 @@ export async function provisionDatabase({
   return { databaseUrl: localDbUrlFor(port), stop: () => pg.stop() };
 }
 
+/** True when pgDir already holds an initialised cluster (initdb completed). */
+export function clusterInitialised(pgDir, exists = existsSync) {
+  return exists(join(pgDir, 'PG_VERSION'));
+}
+
+/** Last lines of the pg_ctl server log, for actionable start-failure errors. */
+async function pgLogTail(logFile, lines = 12) {
+  try {
+    const { readFileSync } = await import('node:fs');
+    const content = readFileSync(logFile, 'utf8').trim().split(/\r?\n/);
+    return ` Server log (${logFile}):\n${content.slice(-lines).join('\n')}`;
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * Windows lifecycle for the embedded cluster, via pg_ctl.
+ *
+ * Why not embedded-postgres's own start(): it spawns postgres.exe directly,
+ * and postgres.exe refuses to run under a token with admin privileges
+ * ("Execution of PostgreSQL by a user with administrative permissions is not
+ * permitted"). initdb self-restricts its token, pg_ctl restricts the token it
+ * starts postgres with — postgres itself does not. Routing start/stop through
+ * pg_ctl works from BOTH elevated and normal shells. Consequence: the server
+ * is detached from this process, so a previous `up` may have left it running —
+ * `pg_ctl status` first, and reuse it on its saved port.
+ *
+ * All effects are injectable for unit tests.
+ */
+export async function provisionEmbeddedWindows({
+  baseDir, pgDir, preferredPort, isFree = isPortFree, logger = console,
+  bins,                    // { pg_ctl } — default: @embedded-postgres/windows-x64
+  spawn = spawnSync,
+  initCluster,             // default: embedded-postgres initialise()
+  connectClient,           // default: pg Client — async (port) => { query, end }
+}) {
+  const localDb = new URL(LOCAL_DB_URL);
+  const pgCtl = bins?.pg_ctl ?? (await import('@embedded-postgres/windows-x64')).pg_ctl;
+  const logFile = join(baseDir, 'pg.log');
+
+  const running = spawn(pgCtl, ['-D', pgDir, 'status'], { stdio: 'ignore' }).status === 0;
+  let port = preferredPort;
+  if (running) {
+    // A detached server from a previous `up` is still serving — reuse it on
+    // the port it was started with (the saved databaseUrl's port). Probing
+    // for a free port here would wrongly route around our own server.
+    logger.error(`[ok] Embedded Postgres already running (port ${port}, data in ${pgDir})`);
+  } else {
+    port = await pickDbPort({ preferred: preferredPort, isFree, logger });
+    const dirPreExisted = existsSync(pgDir);
+    try {
+      if (!clusterInitialised(pgDir)) {
+        if (initCluster) {
+          await initCluster({ pgDir, user: localDb.username, password: localDb.password });
+        } else {
+          const { default: EmbeddedPostgres } = await import('embedded-postgres');
+          await new EmbeddedPostgres({
+            databaseDir: pgDir,
+            user: localDb.username,
+            password: localDb.password,
+            port,
+            persistent: true,
+            initdbFlags: INITDB_FLAGS,
+          }).initialise();
+        }
+      }
+      const res = spawn(
+        pgCtl,
+        ['-D', pgDir, '-o', `-p ${port}`, '-l', logFile, '-w', '-t', '60', 'start'],
+        { stdio: 'ignore' },
+      );
+      if (res.error || res.status !== 0) {
+        const reason = res.error ? res.error.message : `pg_ctl start exited ${res.status}.`;
+        throw new Error(`${reason}${await pgLogTail(logFile)}`);
+      }
+    } catch (e) {
+      if (!dirPreExisted) {
+        rmSync(pgDir, { recursive: true, force: true });
+      }
+      throw new Error(embeddedFailureMessage(e));
+    }
+    logger.error(`[ok] Embedded Postgres running (port ${port}, data in ${pgDir})`);
+  }
+
+  await createDashclawDatabase({ port, localDb, connectClient });
+  return {
+    databaseUrl: localDbUrlFor(port),
+    stop: async () => {
+      spawn(pgCtl, ['-D', pgDir, '-m', 'fast', 'stop'], { stdio: 'ignore' });
+    },
+  };
+}
+
+/** CREATE DATABASE dashclaw, tolerating "already exists" (resume). */
+async function createDashclawDatabase({ port, localDb, connectClient }) {
+  const connect = connectClient ?? (async (p) => {
+    const { default: pg } = await import('pg');
+    const client = new pg.Client({
+      host: 'localhost', port: p,
+      user: localDb.username, password: localDb.password,
+      database: 'postgres',
+    });
+    await client.connect();
+    return client;
+  });
+  const client = await connect(port);
+  try {
+    await client.query(`CREATE DATABASE ${localDb.pathname.slice(1)}`);
+  } catch (e) {
+    if (e.code !== '42P04') throw e; // 42P04 = duplicate_database (resume)
+  } finally {
+    await client.end();
+  }
+}
+
 /** Polls :port until it accepts TCP connections, or throws on timeout. */
 async function waitForPort(port, timeoutMs) {
   const net = await import('node:net');

package/lib/up/index.js

@@ -20,7 +20,7 @@ import { join } from 'node:path';
 import { STEPS, loadInstance, saveInstance, checkpoint } from './instance.js';
 import { resolveAppVersion, downloadAndExtract } from './fetch-app.js';
 import { dockerAvailableSync, chooseDbMode, provisionDatabase } from './db.js';
-import { installDeps, buildApp, startServer, waitForHealth, openBrowser } from './run.js';
+import { installDeps, buildApp, startServer, waitForHealth, openBrowser, winSafeSpawnSync } from './run.js';
 import { installClaude } from '../claude/install.js';
 import { parseUpArgs } from './args.js';
 import { ask } from '../config.js';
@@ -58,7 +58,7 @@ export function resolveBaseDir(args) {
  * @param {object} [opts.logger]
  * @param {Function} [opts.spawn]  injectable spawnSync for testing (default: spawnSync)
  */
-export function runSetupScriptReal({ appDir, databaseUrl, logger = console, spawn: spawnFn = spawnSync }) {
+export function runSetupScriptReal({ appDir, databaseUrl, logger = console, spawn: spawnFn = winSafeSpawnSync }) {
   logger.error('-> Running setup (migrations + first admin) ...');
   const res = spawnFn(
     'node',
@@ -71,7 +71,9 @@ export function runSetupScriptReal({ appDir, databaseUrl, logger = console, spaw
     ],
     // stdin MUST be 'ignore': the default open pipe makes any stray readline
     // prompt in the child hang forever (observed: 12-minute silent hang).
-    { cwd: appDir, encoding: 'utf8', shell: process.platform === 'win32', stdio: ['ignore', 'pipe', 'pipe'] },
+    // Windows shell handling (npm-style .cmd resolution + DEP0190 avoidance)
+    // lives in winSafeSpawnSync.
+    { cwd: appDir, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] },
   );
   const stdout = res.stdout || '';
   const lines = stdout.split('\n').map((l) => l.trim()).filter(Boolean);
@@ -178,7 +180,7 @@ export async function runUp({ args, baseDir = join(homedir(), '.dashclaw'), deps
   // is both wrong and hangs. Reuse the saved URL when db_ready is already
   // checkpointed and inst.databaseUrl is set.
   const dbMode = inst.dbMode ?? await deps.chooseDbMode({
-    flagDb: args.db, dockerAvailable: deps.dockerAvailable, yes: args.yes, promptFn: deps.promptFn,
+    flagDb: args.db, dockerAvailable: deps.dockerAvailable, yes: args.yes, promptFn: deps.promptFn, logger,
   });
   const db = (dbMode === 'url' && done('db_ready') && inst.databaseUrl)
     ? { databaseUrl: inst.databaseUrl, stop: async () => {} }
@@ -313,6 +315,15 @@ export async function runDown({
     dockerStop('dashclaw-pg');
     logger.log('[ok] Stopped Docker Postgres (container dashclaw-pg).');
   }
+  if (inst.dbMode === 'embedded' && process.platform === 'win32') {
+    // On Windows the embedded server runs detached via pg_ctl (see db.js) and
+    // survives the up process — stop it here, best-effort.
+    try {
+      const { pg_ctl } = await import('@embedded-postgres/windows-x64');
+      const res = spawnSync(pg_ctl, ['-D', join(baseDir, 'pg'), '-m', 'fast', 'stop'], { stdio: 'ignore' });
+      if (res.status === 0) logger.log('[ok] Stopped embedded Postgres.');
+    } catch { /* binaries not installed — nothing to stop */ }
+  }
 }
 
 /**

package/lib/up/run.js

@@ -6,26 +6,45 @@ import { spawn, spawnSync } from 'node:child_process';
 
 const shell = process.platform === 'win32';
 
-function npm(args, cwd, logger, runner = spawnSync) {
+// npm/npx are .cmd files on Windows, which node refuses to spawn without a
+// shell — but shell:true + an args ARRAY is deprecated (DEP0190, and the
+// warning prints mid-flow for first-run users). So on Windows the command is
+// joined into ONE string (quoting any arg with shell-special characters) and
+// handed to the shell whole; elsewhere args pass through verbatim, no shell.
+const quoteArg = (a) => (/^[\w\-.:/@=]+$/.test(String(a)) ? String(a) : `"${a}"`);
+export function winSafeSpawnArgs(cmd, args) {
+  return shell
+    ? { cmd: [cmd, ...args.map(quoteArg)].join(' '), args: [], opts: { shell: true } }
+    : { cmd, args, opts: {} };
+}
+
+/** spawnSync that takes LOGICAL (cmd, args) and win-joins only at the edge. */
+export function winSafeSpawnSync(cmd, args, opts) {
+  const safe = winSafeSpawnArgs(cmd, args);
+  return spawnSync(safe.cmd, safe.args, { ...opts, ...safe.opts });
+}
+
+function npm(args, cwd, logger, runner = winSafeSpawnSync) {
   logger.error(`-> npm ${args.join(' ')}`);
-  const res = runner('npm', args, { cwd, stdio: ['ignore', 'inherit', 'inherit'], shell });
+  const res = runner('npm', args, { cwd, stdio: ['ignore', 'inherit', 'inherit'] });
   if (res.status !== 0) throw new Error(`npm ${args[0]} failed (exit ${res.status}). Re-run \`npx dashclaw up\` to resume from this step.`);
 }
 
-export function installDeps(appDir, logger = console, runner = spawnSync) {
+export function installDeps(appDir, logger = console, runner = winSafeSpawnSync) {
   try { npm(['ci', '--no-audit', '--no-fund'], appDir, logger, runner); }
   catch { npm(['install', '--no-audit', '--no-fund'], appDir, logger, runner); } // lockfile mismatch fallback
 }
 
-export function buildApp(appDir, logger = console, runner = spawnSync) {
+export function buildApp(appDir, logger = console, runner = winSafeSpawnSync) {
   npm(['run', 'build'], appDir, logger, runner);
 }
 
 /** Start `next start` as a child; .env.local in appDir is loaded by Next itself. */
 export function startServer({ appDir, port, logger = console }) {
   logger.error(`-> Starting server on :${port}`);
-  const child = spawn('npx', ['next', 'start', '-p', String(port)], {
-    cwd: appDir, stdio: ['ignore', 'inherit', 'inherit'], shell,
+  const safe = winSafeSpawnArgs('npx', ['next', 'start', '-p', String(port)]);
+  const child = spawn(safe.cmd, safe.args, {
+    cwd: appDir, stdio: ['ignore', 'inherit', 'inherit'], ...safe.opts,
   });
   return child;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dashclaw/cli",
-  "version": "0.7.3",
+  "version": "0.7.6",
   "description": "DashClaw terminal client — approve agent actions and diagnose your instance",
   "type": "module",
   "keywords": [
@@ -27,6 +27,7 @@
   "dependencies": {
     "dashclaw": "^2.2.1",
     "embedded-postgres": "18.4.0-beta.17",
+    "pg": "^8.22.0",
     "tar": "^7.4.0"
   },
   "license": "MIT",