@vodmal/vdx-cli 0.20.1 → 0.21.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vodmal/vdx-cli",
-  "version": "0.20.1",
+  "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. */
@@ -959,6 +973,8 @@ export interface ConversationChoice {
   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[];
 }
@@ -976,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
@@ -989,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);
@@ -1058,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) => {
@@ -1072,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 {
@@ -1230,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`] }
@@ -1248,6 +1280,13 @@ export function runAi(opts: AiOptions, deps: AiDeps): number {
   }
   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'],