@detergent-software/conductor 3.0.0-dev.2 → 3.0.0-dev.20

package/build/cli.js

@@ -1,36 +1,42 @@
 #!/usr/bin/env node
 import { spawn } from 'node:child_process';
 import { existsSync, mkdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
-import { join, resolve, sep } from 'node:path';
+import { join, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { parseArgs } from 'node:util';
 import { z } from 'zod';
 import { briefCommand } from "./brief-cli.js";
 import { heldLocks, lockCommand, lockLine, portsCommand } from "./broker-cli.js";
+import { trustStep } from "./claude.js";
 import { callApi, NotRunningError, ping, readEndpoint } from "./client.js";
-import { branchCommand, checkoutCommand, fileCommand, landCommand, modeCommand, prCreateCommand, prThreadsCommand, replyCommand, runsCommand, stateCommand, } from "./code-host-cli.js";
+import { branchCommand, checkoutCommand, fileCommand, landCommand, modeCommand, prCreateCommand, prThreadsCommand, replyCommand, runsCommand, stateCommand, timelineCommand, } from "./code-host-cli.js";
 import { configSchema, loadConfig } from "./config.js";
-import { claimConsole, CONSOLE_WINDOW, consoleArgs, consoleTabArgs, escalationLines, escalationSchema, handledSchema, } from "./console.js";
+import { claimConsole, CONSOLE_WINDOW, consoleArgs, consoleEnv, consoleTab, escalationLines, escalationSchema, handledSchema, } from "./console.js";
 import { AlreadyRunningError, logCrashes, startDaemon } from "./daemon.js";
 import { ConductorError } from "./errors.js";
 import { eventsCommand } from "./events.js";
 import { commandHelp, isCommand, listing, terminalStyle, terminalWidth, unknownCommand, usageError } from "./help.js";
 import { flagWindow, historyLines, historyReport, historySchema, parseRange, retroMarkdown, } from "./history.js";
+import { terminal } from "./host/terminal.js";
 import { inboxLines } from "./inbox.js";
+import { initProject, terminalAsk } from "./init.js";
 import { parseJsonc } from "./jsonc.js";
+import { npmStage } from "./lib/providers/index.js";
 import { processAlive, readPid } from "./lock.js";
 import { rotatingLog } from "./log.js";
 import { fleetWorkerSchema, storedFleet, workerByRef, workerLine } from "./manager.js";
 import { noteCommand } from "./note.js";
 import { isQuiet, notifyLines, notifyStatusSchema, parseUntil, testResultSchema } from "./notify.js";
+import { sharedNpmReads } from "./npm-reads.js";
 import { overrideViewSchema, PAUSE } from "./overrides.js";
 import { packageInfo } from "./package-info.js";
 import { conductorPaths } from "./paths.js";
 import { refreshConductorPlugin } from "./plugin.js";
-import { projectCheckCommand } from "./project-check-cli.js";
+import { profileLines, projectProfile } from "./profile-layers.js";
+import { projectCheckCommand, projectCheckReport } from "./project-check-cli.js";
 import { noProject } from "./project-check.js";
 import { pushoverCredential, pushoverSender } from "./pushover.js";
-import { registerProject } from "./registry.js";
+import { cloneProject, registerProject } from "./registry.js";
 import { rulesLines, rulesService, rulesTestResultSchema, rulesViewSchema, testLines, } from "./rules-service.js";
 import { resolveUntil } from "./rules.js";
 import { outputOf, run } from "./run.js";
@@ -41,10 +47,9 @@ import { installStartup, removeStartup, runStartup, startupRunsCli, startupSuper
 import { answerStopRequest, dropStaleStopRequest, pendingStopRequest, STOP_POLL_MS, stopSupervisor, } from "./stop-request.js";
 import { inboxItemSchema, openStore, projectSchema, waitSchema, workerSchema, } from "./store.js";
 import { RESTART_ENV, restartInfoSchema, SERVE_LOCKED_EXIT, serveChild, supervise, SUPERVISE_POLICY, } from "./supervise.js";
-import { openWindowsTerminal } from "./tab.js";
 import { commentsCommand, notesCommand, searchCommand } from "./tracker-reads-cli.js";
 import { trainCommand } from "./train-cli.js";
-import { parseTag, restartDaemon, upgrade } from "./upgrade.js";
+import { parseTag, restartDaemon, tagVersion, upgrade } from "./upgrade.js";
 import { waitCommand } from "./wait.js";
 import { whyLines, whySchema } from "./why.js";
 const STOP_WAIT_MS = 10_000;
@@ -84,7 +89,13 @@ const retireBody = z.object({
     work: workSchema.extend({ checkouts: z.record(z.string(), workSchema).optional() }).optional(),
     worker: workerSchema,
 });
-const attachBody = z.object({ resumed: z.boolean(), tab: z.string().nullable(), worker: workerSchema });
+// hint: from ATK-529 on; an older daemon sends none.
+const attachBody = z.object({
+    hint: z.string().nullable().default(null),
+    resumed: z.boolean(),
+    tab: z.string().nullable(),
+    worker: workerSchema,
+});
 const inboxBody = z.object({ items: z.array(inboxItemSchema) });
 const answerBody = z.object({
     comment: z.object({ id: z.string(), url: z.string().nullable() }).nullable(),
@@ -96,11 +107,14 @@ const answerRefusal = z.object({
     error: z.string(),
     posted: z.enum(['no', 'unknown']).optional(),
 });
-async function addProject(paths, path) {
-    const absolute = resolve(path);
+// `conduct project add <url | path> [--name <name>]`: the clone is made here, where its progress
+// shows and no API timeout applies, then the daemon registers it (or the store, with none running).
+// `next`: false for `conduct init`, which says what comes next itself.
+async function addProject(paths, source, name, next = true) {
+    const made = await cloneProject(paths, source, { ...(name === undefined ? {} : { name }), say: out });
     let result;
     try {
-        result = addBody.parse(await expectOk(callApi(paths, { body: { path: absolute }, method: 'POST', path: '/projects' })));
+        result = addBody.parse(await expectOk(callApi(paths, { body: { name: made.name }, method: 'POST', path: '/projects' })));
     }
     catch (error) {
         if (!(error instanceof NotRunningError))
@@ -108,9 +122,15 @@ async function addProject(paths, path) {
         // No daemon: write the store directly. The daemon reads it when it starts.
         // Its rules are checked against config.json here too, as the daemon would.
         const check = rulesService({ config: loadConfig(paths.config), listProjects: () => [], paths }).checkProfile;
-        result = withStore(paths, (store) => registerProject(store, absolute, check));
+        result = withStore(paths, (store) => registerProject(store, paths, made.name, check));
     }
     out(`${result.created ? 'registered' : 'updated'} ${projectLine(result.project).trim()}`);
+    out(made.cloned ? `cloned ${made.url} into ${made.clone}` : `fetched ${made.clone}, the clone it has`);
+    out(`its machine profile, which wins over the repo's: ${result.project.profilePath}`);
+    // Claude Code trusts a worktree by its repository, and nobody has run Claude in a new clone yet.
+    if (made.cloned && next)
+        out(`next: ${trustStep(made.clone)}, then \`conduct project check ${made.name}\``);
+    return made;
 }
 // `conduct approve|revise|done`: Jason's answer to an inbox item, by id, or for approve and revise
 // by the item whose plan waits.
@@ -149,6 +169,8 @@ async function attach(paths, ref) {
     out(`${result.resumed ? 'woke' : 'attached to'} ${worker.name} (session ${result.worker.handle ?? '?'})`);
     if (result.tab)
         out(`no tab (${result.tab}); open it yourself: claude attach ${result.worker.handle ?? worker.name}`);
+    else if (result.hint)
+        out(`to see its tab: ${result.hint}`);
 }
 // The pid of the daemon once it answers /health, for upgrade's restart. failure: the detached
 // serve's spawn error, which ends the wait early.
@@ -191,7 +213,7 @@ async function consoleCommand(paths, options) {
         await claimConsole(paths, options.force);
         const child = spawn('claude', consoleArgs(paths.plugin), {
             cwd: paths.console,
-            env: { ...process.env, CONDUCTOR_CONSOLE: '1' },
+            env: consoleEnv(process.env),
             stdio: 'inherit',
         });
         // Ctrl+C belongs to the session; this process only waits for it to end.
@@ -206,26 +228,17 @@ async function consoleCommand(paths, options) {
         });
         return;
     }
-    if (process.platform !== 'win32') {
-        throw new ConductorError('conduct console opens a Windows Terminal tab', [
-            'run `conduct console --here` in a terminal of your own',
-        ]);
-    }
-    // A tab starts with Windows Terminal's environment, not this one's.
-    if (process.env.CONDUCTOR_HOME) {
-        throw new ConductorError('a console tab would not see CONDUCTOR_HOME', [
-            'run `conduct console --here` in a terminal where it is set',
-        ]);
-    }
-    const args = consoleTabArgs(paths.console, process.execPath, realpathSync(fileURLToPath(import.meta.url)));
+    const where = terminal({ choice: loadConfig(paths.config).workers.terminal });
+    const tab = consoleTab(paths.console, process.execPath, realpathSync(fileURLToPath(import.meta.url)), process.env);
     await claimConsole(paths, options.force);
-    const result = await openWindowsTerminal(args, paths.console);
-    if (result.code !== 0)
-        throw new ConductorError('could not open the console tab', [
-            outputOf(result, 500),
+    const failed = await where.open(tab);
+    if (failed !== null)
+        throw new ConductorError(`could not open the console tab in ${where.name}`, [
+            failed,
             'run `conduct console --here --force` in a terminal instead',
         ]);
-    out(`opened the console in ${paths.console} (Windows Terminal window "${CONSOLE_WINDOW}")`);
+    const hint = where.attachHint(CONSOLE_WINDOW);
+    out(`opened the console in ${paths.console} (${hint === null ? `${where.name} window "${CONSOLE_WINDOW}"` : `${where.name}: ${hint}`})`);
 }
 // How `conduct start` and upgrade's restart start the daemon detached from this process.
 function daemonStarter(paths, cliPath) {
@@ -403,7 +416,7 @@ async function listProjects(paths, json) {
     if (json)
         return out(JSON.stringify(projects, null, 2));
     if (projects.length === 0)
-        return out('no projects; add one with `conduct project add <path>`');
+        return out('no projects; add one with `conduct project add <url | path>`');
     projects.forEach((p) => out(projectLine(p)));
 }
 async function main(argv) {
@@ -443,12 +456,15 @@ async function main(argv) {
         options: {
             'allow-downgrade': { type: 'boolean' },
             area: { type: 'string' },
+            base: { type: 'string' },
             'blocked-by': { multiple: true, type: 'string' },
             'body-file': { type: 'string' },
+            branch: { type: 'string' },
             channel: { type: 'string' },
             comments: { type: 'boolean' },
             conductor: { type: 'string' },
             console: { type: 'boolean' },
+            count: { type: 'string' },
             'dry-run': { type: 'boolean' },
             'fail-fast': { type: 'boolean' },
             files: { type: 'string' },
@@ -456,21 +472,24 @@ async function main(argv) {
             for: { type: 'string' },
             force: { type: 'boolean' },
             fresh: { type: 'boolean' },
+            grep: { type: 'string' },
             help: { short: 'h', type: 'boolean' },
             here: { type: 'boolean' },
             human: { type: 'boolean' },
             item: { type: 'string' },
             json: { type: 'boolean' },
+            key: { type: 'string' },
             kind: { type: 'string' },
             last: { type: 'boolean' },
             mode: { type: 'string' },
+            name: { type: 'string' },
             'no-worktree': { type: 'boolean' },
             owner: { type: 'string' },
             phase: { type: 'string' },
-            prefer: { type: 'string' },
             probe: { type: 'boolean' },
             project: { type: 'string' },
             prompt: { type: 'string' },
+            query: { type: 'string' },
             raise: { type: 'boolean' },
             rearm: { type: 'boolean' },
             reason: { type: 'string' },
@@ -478,18 +497,23 @@ async function main(argv) {
             remove: { type: 'boolean' },
             repo: { type: 'string' },
             requeue: { type: 'string' },
+            shared: { type: 'boolean' },
             since: { type: 'string' },
             slots: { type: 'string' },
             tag: { type: 'string' },
+            task: { type: 'string' },
+            team: { type: 'string' },
             text: { type: 'string' },
             tier: { type: 'string' },
             title: { type: 'string' },
+            tracker: { type: 'string' },
             until: { type: 'string' },
             version: { short: 'v', type: 'boolean' },
             wait: { type: 'string' },
             'waits-release': { type: 'boolean' },
             weight: { type: 'string' },
             worker: { type: 'string' },
+            yes: { type: 'boolean' },
         },
     }));
     const paths = conductorPaths();
@@ -516,7 +540,7 @@ async function main(argv) {
         case 'branch':
             if (sub === undefined || arg === undefined)
                 throw usageError('branch');
-            process.exitCode = await branchCommand(sub, arg, item, verbIo());
+            process.exitCode = await branchCommand(paths, sub, arg, item, verbIo());
             return;
         case 'brief':
             if (sub === undefined)
@@ -530,7 +554,7 @@ async function main(argv) {
         case 'checkout':
             if (sub === undefined || arg === undefined || fourth === undefined)
                 throw usageError('checkout');
-            process.exitCode = await checkoutCommand(sub, arg, fourth, item, verbIo());
+            process.exitCode = await checkoutCommand(paths, sub, arg, fourth, item, verbIo());
             return;
         case 'comments': {
             if (sub === undefined || arg !== undefined)
@@ -592,6 +616,26 @@ async function main(argv) {
             });
         case 'inbox':
             return inbox(paths, values.json === true);
+        case 'init':
+            if (arg !== undefined)
+                throw usageError('init');
+            process.exitCode = await initProject({
+                add: (checkout, name) => addProject(paths, checkout, name, false),
+                ask: terminalAsk(),
+                check: (name) => projectCheckReport(paths, name, { worktree: true }, { err: (line) => process.stderr.write(`${line}\n`) }),
+                out,
+                paths,
+            }, sub ?? '.', {
+                shared: values.shared === true,
+                yes: values.yes === true,
+                ...(values.base === undefined ? {} : { base: values.base }),
+                ...(values.key === undefined ? {} : { key: values.key }),
+                ...(values.name === undefined ? {} : { name: values.name }),
+                ...(values.query === undefined ? {} : { query: values.query }),
+                ...(values.team === undefined ? {} : { team: values.team }),
+                ...(values.tracker === undefined ? {} : { tracker: values.tracker }),
+            });
+            return;
         case 'install-startup':
             return values.remove ? uninstall() : install();
         case 'land': {
@@ -638,7 +682,7 @@ async function main(argv) {
                 throw usageError('mode');
             if (tier !== 'S' && tier !== 'M' && tier !== 'L')
                 throw new ConductorError('--tier takes S, M or L');
-            process.exitCode = await modeCommand({ files: values.files, tier }, verbIo());
+            process.exitCode = await modeCommand(paths, { files: values.files, tier }, verbIo());
             return;
         }
         case 'note':
@@ -685,14 +729,23 @@ async function main(argv) {
                 ...(values.until === undefined ? {} : { until: untilOf(values.until) }),
             });
         case 'ports':
-            process.exitCode = await portsCommand(paths, sub, {
-                json: values.json === true,
-                ...(values.prefer === undefined ? {} : { prefer: wholeNumber('--prefer', values.prefer) }),
-            }, brokerIo());
+            process.exitCode = await portsCommand(paths, sub, { json: values.json === true }, brokerIo());
             return;
+        case 'profile': {
+            if (sub === undefined || arg !== undefined)
+                throw usageError('profile');
+            // Resolved here from the machine file and the clone, as the daemon resolves it.
+            const layered = projectProfile(paths, sub);
+            if (values.json === true)
+                return out(JSON.stringify({ profile: layered.profile, sources: layered.sources }, null, 2));
+            profileLines(sub, layered).forEach((line) => out(line));
+            return;
+        }
         case 'project':
-            if (sub === 'add' && arg !== undefined)
-                return addProject(paths, arg);
+            if (sub === 'add' && arg !== undefined) {
+                await addProject(paths, arg, values.name);
+                return;
+            }
             if (sub === 'remove' && arg !== undefined)
                 return removeProject(paths, arg);
             if (sub === 'list')
@@ -733,6 +786,7 @@ async function main(argv) {
                 ...item,
                 ...repo,
                 ...(values.for === undefined ? {} : { for: values.for }),
+                ...(values.grep === undefined ? {} : { grep: values.grep }),
                 ...(values.requeue === undefined ? {} : { requeue: values.requeue }),
             }, verbIo());
             return;
@@ -758,6 +812,19 @@ async function main(argv) {
         case 'supervise':
             process.exitCode = await superviseCommand(paths, values['fail-fast'] === true);
             return;
+        case 'timeline':
+            if (arg !== undefined)
+                throw usageError('timeline');
+            process.exitCode = await timelineCommand(paths, {
+                ...repo,
+                ...(sub === undefined ? {} : { run: sub }),
+                ...(values.branch === undefined ? {} : { branch: values.branch }),
+                ...(values.count === undefined ? {} : { count: values.count }),
+                ...(values.for === undefined ? {} : { for: values.for }),
+                ...(values.grep === undefined ? {} : { grep: values.grep }),
+                ...(values.task === undefined ? {} : { task: values.task }),
+            }, verbIo());
+            return;
         case 'train':
             return trainCommand(paths, sub, { dryRun: values['dry-run'] === true }, { out });
         case 'unpause':
@@ -813,7 +880,7 @@ async function notifyTest(paths, options) {
         ...(options.kind ? { kind: options.kind } : {}),
         raise: options.raise,
     };
-    // Pushover can take its 15 s, after a Credential Manager read.
+    // Pushover can take its 15 s, after a secret store read.
     const answer = await notifyAnswer(paths, { body, method: 'POST', path: '/notify/test', timeoutMs: 60_000 });
     if (options.raise) {
         const { item } = z.object({ item: inboxItemSchema }).parse(answer);
@@ -913,11 +980,11 @@ async function planItem(paths, ref) {
 }
 function projectLine(p) {
     const state = p.problem
-        ? `${p.problem}; the daemon reads ${p.profilePath} again when it starts or the file is saved`
+        ? `${p.problem}; the daemon reads the profile again when it starts, when ~/.conductor/projects/${p.name}.json is saved, and after each fetch of the clone`
         : p.enabled
             ? 'enabled'
             : 'disabled';
-    return `  ${p.name}  ${p.root}  (protocol ${p.protocol}, ${state})`;
+    return `  ${p.name}  ${p.clone}  (protocol ${p.protocol}, ${state})`;
 }
 // The registered projects: from the daemon, or from the store when it isn't running.
 async function projectsNow(paths) {
@@ -962,7 +1029,7 @@ async function removeProject(paths, name) {
         });
     }
     const { project, resolved } = result;
-    out(`removed ${project.name} (${project.root})`);
+    out(`removed ${project.name} (${project.clone})`);
     for (const item of resolved)
         out(`  resolved #${item.id} (${item.kind}${item.item ? ` ${item.item}` : ''})`);
 }
@@ -1156,7 +1223,7 @@ async function status(paths, json) {
     if (json)
         return out(JSON.stringify({ home: paths.home, inbox: items, locks, pid, port, projects, running: true, workers, workersFrom: 'daemon' }, null, 2));
     out(`conductor running (pid ${pid ?? '?'}, port ${port ?? '?'}, home ${paths.home})`);
-    out(projects.length === 0 ? 'no projects; add one with `conduct project add <path>`' : 'projects:');
+    out(projects.length === 0 ? 'no projects; add one with `conduct project add <url | path>`' : 'projects:');
     projects.forEach((p) => out(projectLine(p)));
     out(workers.length === 0 ? 'no workers' : 'workers:');
     workers.forEach((w) => out(workerLine(w)));
@@ -1310,28 +1377,26 @@ function untilOf(text) {
 }
 async function upgradeCommand(paths, tag, allowDowngrade) {
     const cliPath = realpathSync(fileURLToPath(import.meta.url));
+    // npm's own settings, so the tag is read where `npm install --global` installs from (ATK-561).
+    const release = npmStage(sharedNpmReads());
     await upgrade({ allowDowngrade, tag: parseTag(tag) }, {
         ...daemonStarter(paths, cliPath),
         cliPath,
         installedVersion: version,
-        npmInstall: (spec) => npm(['install', '--global', spec], NPM_INSTALL_TIMEOUT_MS),
+        // --prefer-online: npm resolves the exact version against a fresh packument, not a cached one
+        // that may not list it yet (ATK-558).
+        npmInstall: (spec) => npm(['install', '--global', '--prefer-online', spec], NPM_INSTALL_TIMEOUT_MS),
         npmRoot: async () => {
             const result = await npm(['root', '--global']);
             if (result.code !== 0)
                 throw new ConductorError('could not ask npm for its global folder', [outputOf(result)]);
             return realpathSync(result.stdout.trim());
         },
-        npmView: async (spec) => {
-            const result = await npm(['view', spec, 'version']);
-            const found = result.stdout.trim();
-            if (result.code !== 0 || found === '')
-                throw new ConductorError(`npm has no ${spec}`, [outputOf(result)]);
-            return found;
-        },
         out,
         // The installed package's plugin: npm put it where this process's own plugin folder was.
         refreshPlugin: () => void refreshConductorPlugin(paths),
         stopDaemon: () => stopDaemon(paths),
+        tagVersion: (tag) => tagVersion(release, tag),
     });
 }
 function verbIo() {