@vodmal/vdx-cli 0.20.0 → 0.21.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vodmal/vdx-cli",
-  "version": "0.20.0",
+  "version": "0.21.0",
   "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/rubric/vdx-rubric.yaml

@@ -11,7 +11,7 @@ schema_version: "0.2"
 
 metadata:
   name: vdx-rubric-vodmal
-  version: "0.6.0"
+  version: "0.7.0"
   description: "Personal maturity rubric for multi-stack projects (vodmal)"
   owner: vodmal
   homepage: "https://github.com/vodmal/vdx-rubric"

package/src/ai.ts

@@ -12,6 +12,7 @@ import {
   type Conversation,
   describeConversation,
   describeLive,
+  isMachineLabel,
   LIVE_SESSIONS_SCRIPT,
   type LiveSession,
   latestPerMachine,
@@ -19,8 +20,10 @@ import {
   liveConversationId,
   liveSessionsHere,
   machineLine,
+  type MachineReport,
   machineOf,
-  parseLiveSessions,
+  parseMachineReport,
+  runsInProject,
 } from './conversations.ts';
 
 /**
@@ -76,6 +79,8 @@ export interface SessionProfile {
   name?: string;
   /** Tried after `[vdx] name` in the project's mise.toml; the first non-empty string wins. */
   project_names?: NameSource[];
+  /** The machines a project's agent may run on, as ssh destinations; vdx asks the others what runs there. */
+  machines?: string[];
 }
 
 export interface GitProfile {
@@ -183,6 +188,12 @@ export function parseEnvironment(text: string, source: string): Environment {
         }
       });
     }
+    if (session.machines !== undefined) {
+      if (!isStringList(session.machines)) fail('session.machines', 'must be a list of machine names');
+      session.machines.forEach((m, i) => {
+        if (!isMachineLabel(m)) fail(`session.machines[${i}]`, 'must be an ssh destination: letters, digits, . _ - and no leading -');
+      });
+    }
   }
 
   const gitDoc = envDoc.git;
@@ -238,6 +249,8 @@ export interface LaunchPlan {
   confirm: ConfirmRule[];
   multiplexer: Multiplexer;
   sessionName: string;
+  /** The profile's other machines — asked over ssh what runs there before a start. */
+  machines: string[];
 }
 
 export function planLaunch(input: {
@@ -276,6 +289,7 @@ export function planLaunch(input: {
       project: input.project,
       host: input.host,
     }),
+    machines: (environment.session?.machines ?? []).filter((m) => m.toLowerCase() !== input.host.toLowerCase()),
   };
 }
 
@@ -942,12 +956,12 @@ export function runAiRemote(opts: AiOptions, host: string, deps: AiDeps, version
  * The Claude Code sessions alive on `host` right now; null when it does not
  * answer over ssh (BatchMode: a password prompt counts as no answer).
  */
-export function askMachine(host: string, deps: AiDeps): LiveSession[] | null {
+export function askMachine(host: string, deps: AiDeps): MachineReport | null {
   const res = (deps.ssh ?? runSsh)(
     ['-o', 'BatchMode=yes', '-o', 'ConnectTimeout=5', host, `sh -c ${shellQuote(LIVE_SESSIONS_SCRIPT)}`],
     true,
   );
-  return res && res.status === 0 ? parseLiveSessions(res.stdout) : null;
+  return res && res.status === 0 ? parseMachineReport(res.stdout) : null;
 }
 
 /** What a start continues: resume args here, or a conversation on another machine. */
@@ -957,6 +971,10 @@ export interface ConversationChoice {
   remote?: { host: string; id: string; reachable: boolean };
   /** Continue it here only after a yes: another machine's that cannot be asked, or one running here already. */
   askHere?: { id: string; why: string };
+  /** The person ended the question (Ctrl-D): start nothing. */
+  abort?: boolean;
+  /** A new conversation nobody picked, while an agent of the project runs on these machines: only after a yes. */
+  elsewhere?: string[];
   /** For the person: what was found and what is taken. */
   lines: string[];
 }
@@ -974,10 +992,15 @@ const resumeId = (id: string) => ['--resume', id];
  * newest one in the folder, and with the folder synced between machines that
  * can be a conversation another machine is still writing to.
  *
- * Every other machine this project's conversations name is asked over ssh
- * which of them run there right now; this machine's running ones come from
- * its own session files. A running conversation is listed even when it is not
- * its machine's newest.
+ * The profile's other machines, and every other machine this project's
+ * conversations name, are asked over ssh what runs there right now; this
+ * machine's running ones come from its own session files. A running
+ * conversation is listed even when it is not its machine's newest.
+ *
+ * A new conversation the person did not pick from the list — `--new`, a
+ * project with none yet, none of this machine's idle — while an agent of this
+ * project runs on another machine (by the directory it runs in) is started
+ * only after a yes: two agents would work in one repository from two machines.
  *
  * Another machine's conversation is continued on that machine, so two
  * machines never write to one conversation; one whose machine is unknown, or
@@ -987,24 +1010,34 @@ const resumeId = (id: string) => ['--resume', id];
  * idle one, never another's.
  */
 export function chooseConversation(plan: LaunchPlan, deps: AiDeps, canAsk: boolean): ConversationChoice {
-  if (plan.resumeArgs.length === 0 || !isClaude(plan.command)) return { args: plan.resumeArgs, lines: [] };
+  if (!isClaude(plan.command)) return { args: plan.resumeArgs, lines: [] };
   const host = plan.host;
   const same = (a: string | null, b: string | null) => (a ?? '').toLowerCase() === (b ?? '').toLowerCase();
-  const all = listConversations({ env: deps.env, home: deps.home, projectRoot: plan.projectRoot });
-  if (all.length === 0) return { args: [], lines: ['no conversation of this project yet — starting a new one'] };
+  const all = plan.resumeArgs.length === 0 ? [] : listConversations({ env: deps.env, home: deps.home, projectRoot: plan.projectRoot });
+  const root = shellQuote(plan.projectRoot);
 
   // Who runs what right now: this machine from its session files, the others over ssh.
-  const reach = new Map<string, LiveSession[] | null>();
-  for (const c of all) {
-    if (c.machine && !same(c.machine, host) && ![...reach.keys()].some((m) => same(m, c.machine))) {
-      reach.set(c.machine, askMachine(c.machine, deps));
-    }
+  const reach = new Map<string, MachineReport | null>();
+  for (const m of [...plan.machines, ...all.map((c) => c.machine)]) {
+    if (m && !same(m, host) && ![...reach.keys()].some((k) => same(k, m))) reach.set(m, askMachine(m, deps));
   }
+  const silent = [...reach].filter(([, r]) => r === null).map(([m]) => `note: ${m} does not answer over ssh — what runs there is not known`);
+  const elsewhere = [...reach].flatMap(([m, r]) =>
+    (r?.sessions ?? []).filter((l) => runsInProject(l, r!.home, plan.projectRoot, deps.home)).map((l) => ({ m, l })),
+  );
+  const fresh = (lines: string[]): ConversationChoice => {
+    if (elsewhere.length === 0) return { args: [], lines };
+    const agents = elsewhere.map(({ m, l }) => `an agent of this project is ${describeLive(m, l, false)} — there: vdx ai@${m} ${root}`);
+    return { args: [], elsewhere: [...new Set(elsewhere.map(({ m }) => m))], lines: [...lines, ...agents] };
+  };
+  if (plan.resumeArgs.length === 0) return fresh(silent);
+  if (all.length === 0) return fresh(['no conversation of this project yet — starting a new one', ...silent]);
+
   const live = new Map<string, { machine: string; session: LiveSession; here: boolean }[]>();
   const addLive = (machine: string, session: LiveSession, here: boolean) =>
     live.set(session.conversation, [...(live.get(session.conversation) ?? []), { machine, session, here }]);
   for (const l of (deps.liveHere ?? (() => liveSessionsHere(deps.env, deps.home)))()) addLive(host, l, true);
-  for (const [m, sessions] of reach) for (const l of sessions ?? []) addLive(m, l, false);
+  for (const [m, r] of reach) for (const l of r?.sessions ?? []) addLive(m, l, false);
 
   const machine = (c: Conversation) => live.get(c.id)?.find((l) => !l.here)?.machine ?? machineOf(c, host);
   const runsHere = (c: Conversation) => live.get(c.id)?.find((l) => l.here);
@@ -1047,7 +1080,8 @@ export function chooseConversation(plan: LaunchPlan, deps: AiDeps, canAsk: boole
     deps.log('  n) a new conversation');
     for (let tries = 0; tries < 2; tries++) {
       const answer = deps.ask(`Which one to continue? [1]: `);
-      if (answer === null) break;
+      // Ctrl-D at the question is a cancel, not "no terminal": start nothing.
+      if (answer === null) return { args: [], abort: true, lines: ['no answer — nothing started'] };
       const a = answer.trim();
       if (/^n(ew)?$/i.test(a)) return { args: [], lines: ['a new conversation'] };
       const c = a === '' ? found[0] : /^\d+$/.test(a) ? found[Number(a) - 1] : undefined;
@@ -1055,7 +1089,6 @@ export function chooseConversation(plan: LaunchPlan, deps: AiDeps, canAsk: boole
       deps.log(`  1–${found.length}, or n`);
     }
   }
-  const root = shellQuote(plan.projectRoot);
   const notes = found
     .filter((c) => !idleHere(c))
     .map((c) => {
@@ -1069,12 +1102,12 @@ export function chooseConversation(plan: LaunchPlan, deps: AiDeps, canAsk: boole
         ? `note: ${m} has ${which} — continue it there: vdx ai@${m} ${root} --conversation ${c.id}`
         : `note: ${which} is of an unknown machine (never typed in here) — on its machine: vdx ai@<machine> ${root} --conversation ${c.id}`;
     });
-  for (const [m, sessions] of reach) if (sessions === null) notes.push(`note: ${m} does not answer over ssh — what runs there is not known`);
+  notes.push(...silent);
   if (firstIdle) {
     const chosen = take(firstIdle);
     return { ...chosen, lines: [...chosen.lines, ...notes] };
   }
-  return { args: [], lines: ['no idle conversation of this machine — starting a new one', ...notes] };
+  return fresh(['no idle conversation of this machine — starting a new one', ...notes]);
 }
 
 interface Prepared {
@@ -1227,7 +1260,9 @@ export function runAi(opts: AiOptions, deps: AiDeps): number {
   let choice: ConversationChoice | null = null;
   if (!current || opts.restart) {
     if (opts.conversation) choice = { args: resumeId(opts.conversation), lines: [] };
-    else if (current && plan.resumeArgs.length > 0 && isClaude(plan.command)) {
+    // A restart into a new conversation replaces the agent here: no second agent, nothing to ask.
+    else if (current && plan.resumeArgs.length === 0) choice = { args: [], lines: [] };
+    else if (current && isClaude(plan.command)) {
       const live = liveConversationId(deps.env, deps.home, current.proc.pid);
       choice = live
         ? { args: resumeId(live), lines: [`the agent is in conversation ${live.slice(0, 8)} — resuming it`] }
@@ -1244,6 +1279,14 @@ export function runAi(opts: AiOptions, deps: AiDeps): number {
     return EXIT_OK;
   }
   for (const l of choice?.lines ?? []) log(l);
+  if (choice?.abort) return EXIT_LAUNCH_FAILED;
+  if (choice?.elsewhere && !current) {
+    const answer = deps.interactive ? deps.ask(`Start a new conversation here, on ${plan.host}, anyway? [y/N]: `) : null;
+    if (!/^y(es)?$/i.test(answer?.trim() ?? '')) {
+      log('nothing started');
+      return EXIT_LAUNCH_FAILED;
+    }
+  }
 
   let askHere = choice?.askHere;
   if (choice?.remote) {

package/src/conversations.ts

@@ -38,6 +38,11 @@ export function machineLine(label: string): string {
   return `${MACHINE_LINE_PREFIX} \`${label}\``;
 }
 
+/** A machine label vdx may hand to ssh as the destination. */
+export function isMachineLabel(s: string): boolean {
+  return LABEL_RE.test(s);
+}
+
 export function isConversationId(s: string): boolean {
   return ID_RE.test(s);
 }
@@ -206,6 +211,8 @@ export interface LiveSession {
   tmux: string | null;
   /** Claude Code's own word for it: `busy`, `waiting`, … */
   status: string | null;
+  /** The directory it was started in — on its own machine. */
+  cwd: string | null;
 }
 
 /** Session files, one JSON object per line — a file read here, or the output of LIVE_SESSIONS_SCRIPT. */
@@ -225,11 +232,32 @@ export function parseLiveSessions(text: string): LiveSession[] {
       conversation: data.sessionId,
       tmux: typeof data.tmux === 'string' ? data.tmux : null,
       status: typeof data.status === 'string' ? data.status : null,
+      cwd: typeof data.cwd === 'string' ? data.cwd : null,
     });
   }
   return out;
 }
 
+/** `~/AI Projects/x` for a path under `home`; any other path as is. */
+function fromHome(p: string, home: string): string {
+  const rel = path.relative(home, p);
+  if (rel === '') return '~';
+  return rel.startsWith('..') || path.isAbsolute(rel) ? p : `~/${rel}`;
+}
+
+/**
+ * The session runs in the project: its directory is the project's root or
+ * below it. Paths of two machines are compared from their homes — `vdx
+ * ai@<host>` puts a project under the same place in the other home; with that
+ * home unknown, as they are.
+ */
+export function runsInProject(live: LiveSession, liveHome: string | null, projectRoot: string, home: string): boolean {
+  if (!live.cwd) return false;
+  const cwd = liveHome ? fromHome(live.cwd, liveHome) : live.cwd;
+  const root = liveHome ? fromHome(projectRoot, home) : projectRoot;
+  return cwd === root || cwd.startsWith(root.endsWith('/') ? root : `${root}/`);
+}
+
 function pidAlive(pid: number): boolean {
   try {
     process.kill(pid, 0);
@@ -244,8 +272,11 @@ function pidAlive(pid: number): boolean {
  * runs on, one per line — what `vdx ai` asks another machine over ssh. Claude
  * removes the file of a process that ended, but not after a crash or a reboot:
  * the pid is checked. `<pid>.sync-conflict-….json` is not a session file.
+ * The first line, `home=<dir>`, places the sessions' directories in that
+ * machine's home (see runsInProject).
  */
 export const LIVE_SESSIONS_SCRIPT =
+  'printf "home=%s\\n" "$HOME"; ' +
   'd="${CLAUDE_CONFIG_DIR:-$HOME/.claude}/sessions"; for f in "$d"/*.json; do ' +
   'p=${f##*/}; p=${p%.json}; case $p in ""|*[!0-9]*) continue;; esac; ' +
   'kill -0 "$p" 2>/dev/null && tr -d "\\n" < "$f" && echo; done; exit 0';
@@ -272,6 +303,17 @@ export function liveSessionsHere(env: NodeJS.ProcessEnv, home: string, alive: (p
   return parseLiveSessions(lines.join('\n'));
 }
 
+/** What another machine runs right now: its home and the Claude Code sessions alive there. */
+export interface MachineReport {
+  home: string | null;
+  sessions: LiveSession[];
+}
+
+/** The output of LIVE_SESSIONS_SCRIPT. */
+export function parseMachineReport(text: string): MachineReport {
+  return { home: text.match(/^home=(.+)$/m)?.[1] ?? null, sessions: parseLiveSessions(text) };
+}
+
 /** "running on m3 now (t23b-program@m3, waiting)" — where a live session is, for a person choosing. */
 export function describeLive(machine: string, live: LiveSession, here: boolean): string {
   const where = live.tmux ? live.tmux.replace(/:.*$/, '') : `pid ${live.pid}`;

package/src/index.ts

@@ -88,11 +88,13 @@ the project's files). Hand a person \`vdx ai\`, not \`<agent> --<flag>\`.
 
 Which conversation a start continues (Claude Code): each one is marked with the
 machine it was last started on (the vdx plugin's hook writes it in), and the
-other machines are asked over ssh which ones run there now. Another machine's
-conversation is continued on that machine; if it does not answer, vdx asks
-before continuing it here. When the choice is not plain, vdx lists them, the
-running ones marked — Enter takes the newest; without a terminal it takes this
-machine's.
+other machines (session.machines in the profile, and those the conversations
+name) are asked over ssh what runs there now. Another machine's conversation
+is continued on that machine; if it does not answer, vdx asks before
+continuing it here. When the choice is not plain, vdx lists them, the running
+ones marked — Enter takes the newest; without a terminal it takes this
+machine's. A new conversation (--new, or none to continue) while an agent of
+the project runs on another machine starts only after a yes.
 
 Exit codes: 0 the agent runs per the profile; 2 profile or usage error;
 3 the running agent lacks profile flags (rerun with --restart); 4 the start

package/src/init.ts

@@ -12,7 +12,7 @@ import {
 export const STANDARD_VERBS = ['up', 'down', 'build', 'test', 'check', 'fix'] as const;
 export type Verb = (typeof STANDARD_VERBS)[number];
 
-export const DEFAULT_BASELINE = 'github.com/VoDmAl/vdx-rubric-vodmal@v0.6.0';
+export const DEFAULT_BASELINE = 'github.com/VoDmAl/vdx-rubric-vodmal@v0.7.0';
 
 const VERB_ALIASES: Record<Verb, string[]> = {
   up: ['docker:up', 'docker-up', 'docker:up:detached', 'start', 'dev', 'serve'],

package/src/publish.ts

@@ -392,6 +392,8 @@ export interface PublishDeps {
   sleep: (ms: number) => void;
   /** How long to wait for the registry to show the new version. */
   registryWaitMs: number;
+  /** Rewrites one status line in place (a terminal); without it the wait logs a line now and then. */
+  progress?: (text: string) => void;
 }
 
 function sleepSync(ms: number): void {
@@ -407,6 +409,7 @@ export function defaultPublishDeps(): PublishDeps {
     log: (line) => process.stderr.write(line + '\n'),
     sleep: sleepSync,
     registryWaitMs: 180_000,
+    progress: process.stderr.isTTY ? (text) => process.stderr.write(`\r${text}\x1b[K`) : undefined,
   };
 }
 
@@ -427,19 +430,38 @@ export function bumpLockText(text: string, version: string): string {
 export function waitForRegistry(name: string, version: string, deps: PublishDeps): boolean {
   const started = Date.now();
   const deadline = started + deps.registryWaitMs;
-  deps.log(`→ waiting for the registry to show ${name}@${version}...`);
-  for (;;) {
+  const limit = Math.round(deps.registryWaitMs / 1000);
+  const seconds = () => Math.round((Date.now() - started) / 1000);
+  deps.log(
+    `→ waiting for the registry to show ${name}@${version} — npm has taken it; ` +
+      `the registry usually shows it within ~2 min (giving it ${limit} s)`,
+  );
+  const shown = () => {
     try {
-      if (deps.npm(['view', `${name}@${version}`, 'version', '--prefer-online']).trim() === version) {
-        deps.log(`✓ ${name}@${version} is on the registry (${Math.round((Date.now() - started) / 1000)} s after publish)`);
-        return true;
-      }
+      return deps.npm(['view', `${name}@${version}`, 'version', '--prefer-online']).trim() === version;
     } catch {
-      /* E404 until it is processed */
+      return false; // E404 until it is processed
+    }
+  };
+  // Ask npm every 10 s; between the asks, count the seconds on one line.
+  let lastLogged = 0;
+  for (let found = shown(); ; found = shown()) {
+    if (found) {
+      deps.progress?.('');
+      deps.log(`✓ ${name}@${version} is on the registry (${seconds()} s after publish)`);
+      return true;
     }
     if (Date.now() >= deadline) break;
-    deps.sleep(10_000);
+    for (let i = 0; i < 10 && Date.now() < deadline; i++) {
+      if (deps.progress) deps.progress(`  … ${seconds()} s of ${limit} s`);
+      else if (seconds() - lastLogged >= 30) {
+        lastLogged = seconds();
+        deps.log(`  … ${lastLogged} s`);
+      }
+      deps.sleep(1_000);
+    }
   }
+  deps.progress?.('');
   deps.log(
     `! ${name}@${version} not visible on the registry after ${Math.round(deps.registryWaitMs / 60_000)} min — ` +
       `npm accepted it; check later: npm view ${name}@${version} version`,