@vodmal/vdx-cli 0.12.1 → 0.13.1

package/README.md

@@ -48,7 +48,10 @@ vdx publish <patch|minor|major> [--dry-run] [--force]
 vdx doctor [--format=ansi|markdown|json]
 
 # Start your agent in a project per your profile (~/.vdx-environment.yaml or $VDX_ENVIRONMENT)
-vdx ai [project-path] [--restart] [--resume] [--detach] [--dry-run]   # default: cwd
+vdx ai [project-path] [--new] [--restart] [--detach] [--dry-run]   # default: cwd
+
+# Print the installed version
+vdx --version
 
 # MCP stdio server consumed by the Claude Code plugin
 vdx-mcp   --project <path>
@@ -67,7 +70,8 @@ vdx test            # → mise run test (which calls `vitest run` or whatever wa
 # 3. Ship a new minor release of a Node lib
 vdx publish minor   # bump → npm publish (OTP prompt) → git commit + tag (no push)
 
-# 4. Start the agent here; re-run to attach, --restart to apply a changed profile
+# 4. Start the agent here, continuing its last conversation (--new: a new one);
+#    re-run to attach, --restart to apply a changed profile
 vdx ai
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vodmal/vdx-cli",
-  "version": "0.12.1",
+  "version": "0.13.1",
   "description": "vdx — unified lifecycle interface (up/down/build/test/check/fix) + versioned maturity audit with drift detection. Pairs with the vdx Claude Code plugin.",
   "keywords": [
     "vdx",

package/src/ai.ts

@@ -13,6 +13,10 @@ import type { Predicate } from './rubric.ts';
  * and hands it to tmux, or runs it in this terminal when tmux is not wanted or
  * not installed.
  *
+ * A start continues the project's last conversation (the profile's
+ * `resume_args`) — after a reboot `vdx ai` brings the agent back where it was;
+ * `--new` starts a new conversation.
+ *
  * The profile is personal (which agent, which permissions), so it is never
  * bundled into the CLI: it is read from `$VDX_ENVIRONMENT` or
  * `~/.vdx-environment.yaml`. Without one, vdx starts a plain `claude` or
@@ -499,7 +503,8 @@ export class Tmux {
 export interface AiOptions {
   path: string;
   restart: boolean;
-  resume: boolean;
+  /** `--new`: start a new conversation — leave out the profile's resume args. */
+  fresh: boolean;
   detach: boolean;
   dryRun: boolean;
 }
@@ -544,6 +549,13 @@ export const EXIT_USAGE = 2;
 export const EXIT_DRIFT = 3;
 export const EXIT_LAUNCH_FAILED = 4;
 
+/**
+ * Without tmux the agent runs in the foreground. One that fails this soon after
+ * a start with the resume args had nothing to resume (`claude --continue` exits
+ * 1 at once); the window covers answering the channel prompt that comes first.
+ */
+export const NOTHING_TO_RESUME_MS = 30_000;
+
 export function renderPlan(plan: LaunchPlan, multiplexer: Multiplexer, running: AgentPane[]): string {
   const lines = [
     `vdx ai — ${plan.projectRoot}`,
@@ -658,9 +670,9 @@ function settle(plan: LaunchPlan, paneId: string, deps: AiDeps): SettleResult {
 }
 
 /**
- * Settle a pane that was started with the resume args. An agent with nothing to
- * resume exits at once; start it once more without them rather than leave the
- * project without an agent.
+ * Settle a pane started with the plan's resume args, if it has any. An agent
+ * with nothing to resume exits at once; start it once more without them rather
+ * than leave the project without an agent.
  */
 function settleResumed(plan: LaunchPlan, paneId: string, deps: AiDeps): boolean {
   const result = settle(plan, paneId, deps);
@@ -724,6 +736,8 @@ export function runAi(opts: AiOptions, deps: AiDeps): number {
     log(`vdx ai: ${profilePath ?? 'profile'}: ${e?.message ?? e}`);
     return EXIT_USAGE;
   }
+  // A start continues the last conversation unless asked for a new one.
+  if (opts.fresh) plan = { ...plan, resumeArgs: [] };
 
   let multiplexer = plan.multiplexer;
   if (multiplexer === 'tmux' && !tmux.available()) {
@@ -751,12 +765,17 @@ export function runAi(opts: AiOptions, deps: AiDeps): number {
       return EXIT_USAGE;
     }
     for (const c of plan.confirm) log(`note: the agent will ask "${c.screen}" — answer it with ${c.keys.join(' ')}`);
-    const args = [...plan.args, ...(opts.resume ? plan.resumeArgs : [])];
-    const res = spawnSync(plan.command, args, { cwd: projectRoot, stdio: 'inherit' });
+    const startedAt = Date.now();
+    let res = spawnSync(plan.command, [...plan.args, ...plan.resumeArgs], { cwd: projectRoot, stdio: 'inherit' });
     if ((res.error as NodeJS.ErrnoException | undefined)?.code === 'ENOENT') {
       log(`vdx ai: \`${plan.command}\` not found on PATH`);
       return 127;
     }
+    const failedAtOnce = res.status !== null && res.status !== 0 && Date.now() - startedAt < NOTHING_TO_RESUME_MS;
+    if (plan.resumeArgs.length > 0 && failedAtOnce) {
+      log(`↻ nothing to resume — starting without ${plan.resumeArgs.join(' ')}: ${commandLine(plan.command, plan.args)}`);
+      res = spawnSync(plan.command, plan.args, { cwd: projectRoot, stdio: 'inherit' });
+    }
     return res.status ?? 1;
   }
 
@@ -769,14 +788,17 @@ export function runAi(opts: AiOptions, deps: AiDeps): number {
   }
 
   if (current && !opts.restart) {
+    if (opts.fresh) log(`note: ${current.pane.session} already runs ${plan.command} — --new replaces it only with --restart`);
     const missing = missingArgs(current.proc.args, plan.args);
     if (missing.length > 0) {
       log(`✗ ${current.pane.session}: ${plan.command} is running without ${missing.join(' ')}`);
       log(
-        `  to apply the profile: vdx ai --restart ${shellQuote(projectRoot)}` +
+        `  to apply the profile: vdx ai --restart${opts.fresh ? ' --new' : ''} ${shellQuote(projectRoot)}` +
           (plan.resumeArgs.length
             ? ` (stops the running agent, then resumes the conversation with ${plan.resumeArgs.join(' ')})`
-            : ' (stops the running agent; the conversation is not resumed — the profile has no resume_args)'),
+            : opts.fresh
+              ? ' (stops the running agent and starts a new conversation)'
+              : ' (stops the running agent; the conversation is not resumed — the profile has no resume_args)'),
       );
       return EXIT_DRIFT;
     }
@@ -791,14 +813,13 @@ export function runAi(opts: AiOptions, deps: AiDeps): number {
     return finish(settleResumed(plan, current.pane.paneId, deps), current.pane.session, current.pane.paneId, opts, deps);
   }
 
-  if (opts.restart) log(`note: no running ${plan.command} in this project — starting a new one`);
-  const line = commandLine(plan.command, [...plan.args, ...(opts.resume ? plan.resumeArgs : [])]);
+  if (opts.restart) log(`note: no running ${plan.command} in this project — starting one`);
+  const line = commandLine(plan.command, [...plan.args, ...plan.resumeArgs]);
   const cmd = tmuxShellCommand(line, deps.shell);
   const reuse = tmux.hasSession(plan.sessionName);
   const paneId = reuse
     ? tmux.newWindow(plan.sessionName, projectRoot, cmd)
     : tmux.newSession(plan.sessionName, projectRoot, cmd);
   log(`▶ ${plan.sessionName}${reuse ? ' (new window)' : ''}: ${line}`);
-  const ok = opts.resume ? settleResumed(plan, paneId, deps) : settle(plan, paneId, deps) === 'ok';
-  return finish(ok, plan.sessionName, paneId, opts, deps);
+  return finish(settleResumed(plan, paneId, deps), plan.sessionName, paneId, opts, deps);
 }

package/src/doctor.ts

@@ -162,7 +162,7 @@ function checkNpmAuth(): CheckResult {
       id: 'npm-auth',
       label: 'npm auth',
       status: 'warning',
-      message: 'not logged in — `vdx publish` will fail with E404',
+      message: 'not logged in — `vdx publish` refuses at pre-flight (npm-auth)',
       remedy: 'npm login',
     };
   }

package/src/index.ts

@@ -19,7 +19,7 @@ import {
   reportDoctorJson,
   reportDoctorAnsi,
 } from './report.ts';
-import { runDoctor, looksLikeProject } from './doctor.ts';
+import { runDoctor, looksLikeProject, readCliVersion } from './doctor.ts';
 import { planInit, writeInit, renderPlanSummary } from './init.ts';
 import {
   planPublish,
@@ -41,7 +41,8 @@ function usage(): never {
   vdx init    [project_path]  [--stack <id>] [--baseline <ref>] [--dry-run] [--force]                     (default: cwd)
   vdx publish <patch|minor|major> [--dry-run] [--force]
   vdx doctor  [--format=ansi|markdown|json] [--json]
-  vdx ai      [project_path]  [--restart] [--resume] [--detach] [--dry-run]                                 (default: cwd)
+  vdx ai      [project_path]  [--new] [--restart] [--detach] [--dry-run]                                    (default: cwd)
+  vdx --version
 `,
   );
   process.exit(1);
@@ -271,16 +272,20 @@ function cmdAi(opts: ParsedArgs): void {
     return v !== undefined;
   };
   const restart = bool('restart');
-  const resume = bool('resume');
+  const fresh = bool('new');
+  // `--resume` asked to continue in 0.12; continuing is the default now.
+  // Still read, so the path after it is not taken for its value.
+  bool('resume');
   const detach = bool('detach');
   const dryRun = bool('dry-run');
   process.exit(
-    runAi({ path: positionals[0] ?? '.', restart, resume, detach, dryRun }, defaultDeps()),
+    runAi({ path: positionals[0] ?? '.', restart, fresh, detach, dryRun }, defaultDeps()),
   );
 }
 
 const parsed = parseArgs(process.argv);
-if (parsed.cmd === 'audit') cmdAudit(parsed);
+if (parsed.cmd === '--version') process.stdout.write(readCliVersion() + '\n');
+else if (parsed.cmd === 'audit') cmdAudit(parsed);
 else if (parsed.cmd === 'init') cmdInit(parsed);
 else if (parsed.cmd === 'publish') cmdPublish(parsed);
 else if (parsed.cmd === 'doctor') cmdDoctor(parsed);

package/src/publish.ts

@@ -79,12 +79,21 @@ function isGitWorkingTreeClean(projectRoot: string): { ok: boolean; detail: stri
   }
 }
 
-function fetchPublishedVersion(packageName: string): string | null {
+/** Runs npm with these args and returns stdout; throws with `stderr` on a non-zero exit. */
+export type NpmRunner = (args: string[]) => string;
+
+// A caller's `npm run -s` passes `npm_config_loglevel=silent` down, and npm then
+// fails with an empty stderr — no E401 or E404 left to tell the cases apart.
+const runNpm: NpmRunner = (args) =>
+  execFileSync('npm', args, {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+    env: { ...process.env, npm_config_loglevel: 'error' },
+  });
+
+function fetchPublishedVersion(packageName: string, npm: NpmRunner): string | null {
   try {
-    const out = execFileSync('npm', ['view', packageName, 'version'], {
-      encoding: 'utf8',
-      stdio: ['ignore', 'pipe', 'pipe'],
-    });
+    const out = npm(['view', packageName, 'version']);
     return out.trim() || null;
   } catch (e: any) {
     const stderr = String(e?.stderr ?? e?.message ?? '');
@@ -93,6 +102,54 @@ function fetchPublishedVersion(packageName: string): string | null {
   }
 }
 
+/**
+ * The registry `npm publish` sends this package to, when it is not npm's
+ * default: `publishConfig.registry`, else the scope's registry from npm config.
+ */
+export function publishRegistry(
+  pkg: { name?: string; publishConfig?: { registry?: string } },
+  npm: NpmRunner,
+): string | null {
+  if (pkg.publishConfig?.registry) return pkg.publishConfig.registry;
+  const scope = pkg.name?.match(/^(@[^/]+)\//)?.[1];
+  if (!scope) return null;
+  try {
+    const value = npm(['config', 'get', `${scope}:registry`]).trim();
+    return value && value !== 'undefined' ? value : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Logged in where the package goes? Without it `npm publish` fails only after
+ * the bump and the pack, and with E404 on a scoped package, not E401 — an
+ * expired npm session reads as a missing package.
+ */
+export function checkNpmAuth(registry: string | null, npm: NpmRunner): PreflightCheck {
+  const where = registry ?? 'npm';
+  const login = registry ? `npm login --registry ${registry}` : 'npm login';
+  try {
+    const who = npm(registry ? ['whoami', '--registry', registry] : ['whoami']).trim();
+    if (who) return { name: 'npm-auth', ok: true, message: `OK (logged in to ${where} as ${who})` };
+    return { name: 'npm-auth', ok: false, message: `npm whoami answered nothing for ${where}. Run: ${login}` };
+  } catch (e: any) {
+    const stderr = String(e?.stderr ?? e?.message ?? '');
+    if (/E401|ENEEDAUTH/.test(stderr)) {
+      return {
+        name: 'npm-auth',
+        ok: false,
+        message: `not logged in to ${where} (the npm session may have expired). Run: ${login}`,
+      };
+    }
+    return {
+      name: 'npm-auth',
+      ok: false,
+      message: `npm whoami failed for ${where}: ${stderr.split('\n').find((l) => l.trim()) ?? stderr}`,
+    };
+  }
+}
+
 function checkMiseOverride(projectRoot: string): boolean {
   const miseToml = path.join(projectRoot, 'mise.toml');
   if (!fs.existsSync(miseToml)) return false;
@@ -116,6 +173,7 @@ export function planPublish(
   opts: PublishOptions,
   audit: AuditResult,
   ctx: Ctx,
+  npm: NpmRunner = runNpm,
 ): PublishPlan {
   if (checkMiseOverride(opts.projectRoot)) {
     return {
@@ -197,10 +255,12 @@ export function planPublish(
         : `release-artifact at ${raLevel}, need >= L3. Add files[], main/exports, license in package.json.`,
   });
 
+  preflight.push(checkNpmAuth(publishRegistry(pkg, npm), npm));
+
   let published: string | null = null;
   let registryError: string | null = null;
   try {
-    published = fetchPublishedVersion(packageName);
+    published = fetchPublishedVersion(packageName, npm);
   } catch (e: any) {
     registryError = e?.message ?? String(e);
   }