peaks-loop 4.1.2 → 4.1.4

package/dist/cli/commands/test-commands.js

@@ -32,180 +32,17 @@
  *   peaks test --no-cache             — pass --no-cache to the framework
  *   peaks test --passthrough          — do NOT override the consumer's argv
  *   peaks test --framework <name>     — force a specific framework
+ *
+ * The runner resolution and this file's spawn site live here; the action body
+ * it dispatches to lives in `test-command-run.ts` and the argv/probe rules in
+ * `test-command-runner-resolution.ts`.
  */
 import { spawn } from 'node:child_process';
-import { existsSync, readFileSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
-import { resolveCanonicalProjectRoot } from '../../services/config/config-service.js';
+import { join } from 'node:path';
 import { getErrorMessage } from '../cli-helpers.js';
-import { clearTestCache, detectTestFramework } from '../../services/test-cache/test-cache-service.js';
-const FRAMEWORKS = ['jest', 'vitest', 'mocha'];
-/**
- * Build the argv for the underlying test runner. This is the SINGLE
- * source of truth for "peaks test drops --no-cache from the
- * consumer's script" (G7 / NG7). `--cache` is always passed
- * unless the user explicitly opts in to `--no-cache` or `--passthrough`.
- */
-export function buildRunnerArgv(framework, patterns, options) {
-    if (options.passthrough) {
-        // Caller has explicitly chosen to honor the consumer's argv;
-        // we still pass the patterns so the runner filters to them.
-        if (framework === 'jest')
-            return [...patterns, '--no-cache'];
-        if (framework === 'vitest')
-            return ['run', ...patterns];
-        return [...patterns];
-    }
-    if (framework === 'jest') {
-        const argv = [...patterns];
-        if (options.all)
-            argv.push('--passWithNoTests');
-        if (options.changed)
-            argv.push('--changedSince=HEAD');
-        // Commander's `.option('--no-cache')` sets `opts.cache` (BASE name) to
-        // `false` when the flag is passed; `opts.cache` is `true` by default.
-        // The default-mode invariant (G7/NG7) is `--cache`; the explicit
-        // override is `--no-cache`. Inverted from the previous wording
-        // because `options = {}` made the read side `!== true` and silently
-        // flipped every default-mode jest/vitest run to `--no-cache`.
-        if (options.cache === false)
-            argv.push('--no-cache');
-        else
-            argv.push('--cache');
-        return argv;
-    }
-    if (framework === 'vitest') {
-        const argv = ['run', ...patterns];
-        if (options.changed)
-            argv.push('--changed');
-        if (options.cache === false)
-            argv.push('--no-cache');
-        else
-            argv.push('--cache');
-        return argv;
-    }
-    // mocha — no built-in --cache flag; we just pass the patterns.
-    return [...patterns];
-}
-/** `<pkg>/package.json#bin`, resolved to the absolute JS entry it points at. */
-function readBinEntry(pkgJsonPath, name, read) {
-    let pkg = {};
-    try {
-        pkg = JSON.parse(read(pkgJsonPath));
-    }
-    catch {
-        // Not fatal: fall through to the `.bin` shim below, and the not-found
-        // error still names this package.json in `searched`.
-        pkg = {};
-    }
-    const rel = typeof pkg.bin === 'string' ? pkg.bin : pkg.bin?.[name];
-    if (typeof rel !== 'string' || rel.length === 0)
-        return null;
-    return resolve(dirname(pkgJsonPath), rel);
-}
-/**
- * Convert a resolved executable + argv into a form `spawn` can launch with
- * `shell: false`.
- *
- * A Windows `.cmd`/`.bat` shim cannot be spawned directly (spawn → EINVAL).
- * The obvious fix, `spawn(shim, argv, { shell: true })`, re-splits argv inside
- * cmd.exe: a pattern `tests/a b/x.test.ts` arrives as THREE args (measured).
- * Invoking cmd.exe ourselves with `/d /s /c` keeps argv intact.
- */
-function toSpawnable(exe, argv, platform, env) {
-    if (platform === 'win32' && /\.(?:cmd|bat)$/i.test(exe)) {
-        return { command: env.ComSpec ?? 'cmd.exe', args: ['/d', '/s', '/c', exe, ...argv] };
-    }
-    return { command: exe, args: argv };
-}
-/** Spawnable PATH hits, in preference order (`where`/`which` avoided so this
- * stays in-process and testable). */
-function resolveFromPath(name, platform, env, exists) {
-    const dirs = (env.PATH ?? '').split(platform === 'win32' ? ';' : ':').filter((d) => d.length > 0);
-    const exts = platform === 'win32' ? ['.exe', '.cmd', '.bat', ''] : [''];
-    for (const dir of dirs) {
-        for (const ext of exts) {
-            const candidate = join(dir, name + ext);
-            if (exists(candidate))
-                return candidate;
-        }
-    }
-    return null;
-}
-/**
- * Resolve the consumer project's LOCAL runner, and the form of it that
- * `spawn` can actually launch on this platform.
- *
- * Probed, in order (every probe is reported when nothing is found):
- *   1. `<root>/node_modules/.bin/<runner>` (+ `.cmd`/`.exe` on Windows) —
- *      the project-local runner the command documents.
- *   2. `<root>/node_modules/<runner>/package.json` → its `bin` JS entry.
- *   3. PATH — last resort only; the caller prints a visible notice.
- *
- * Between 1 and 2 the **JS entry** wins: `spawn` runs it as
- * `node <entry> …`, which is identical on Windows and POSIX and never
- * routes argv through a shell. The `.cmd` shim is only a fallback because
- * it needs cmd.exe to launch it (see `toSpawnable`).
- */
-export function resolveRunner(framework, argv, projectRoot, deps = {}) {
-    const platform = deps.platform ?? process.platform;
-    const exists = deps.existsSync ?? existsSync;
-    const read = deps.readFileSync ?? ((path) => readFileSync(path, 'utf8'));
-    const env = deps.env ?? process.env;
-    const nodeExec = deps.nodeExecPath ?? process.execPath;
-    const searched = [];
-    // 1. Project-local `.bin` shim.
-    const binDir = join(projectRoot, 'node_modules', '.bin');
-    const shimExts = platform === 'win32' ? ['.cmd', '.exe'] : [''];
-    let shim = null;
-    for (const ext of shimExts) {
-        const candidate = join(binDir, framework + ext);
-        searched.push(candidate);
-        if (shim === null && exists(candidate))
-            shim = candidate;
-    }
-    // 2. Project-local package entry.
-    const pkgJsonPath = join(projectRoot, 'node_modules', framework, 'package.json');
-    searched.push(pkgJsonPath);
-    const entry = exists(pkgJsonPath) ? readBinEntry(pkgJsonPath, framework, read) : null;
-    if (entry !== null && exists(entry)) {
-        return {
-            ok: true,
-            command: nodeExec,
-            args: [entry, ...argv],
-            via: `local ${entry}`,
-            fromPath: false
-        };
-    }
-    if (shim !== null) {
-        return {
-            ok: true,
-            ...toSpawnable(shim, argv, platform, env),
-            via: `local ${shim}`,
-            fromPath: false
-        };
-    }
-    // 3. PATH — last resort.
-    const onPath = resolveFromPath(framework, platform, env, exists);
-    searched.push(`PATH lookup for "${framework}"`);
-    if (onPath !== null) {
-        return {
-            ok: true,
-            ...toSpawnable(onPath, argv, platform, env),
-            via: `PATH: ${onPath}`,
-            fromPath: true
-        };
-    }
-    return { ok: false, searched };
-}
-/** Actionable message for the no-runner case — never a raw ENOENT. */
-export function formatRunnerNotFound(framework, searched) {
-    return [
-        `RUNNER_NOT_FOUND: no ${framework} runner found for this project. Looked for:`,
-        ...searched.map((p) => `  - ${p}`),
-        `Install it (e.g. \`npm i -D ${framework}\`) or pass --framework <name>.`
-    ].join('\n');
-}
+import { resolveCanonicalProjectRoot } from '../../services/config/config-service.js';
+import { buildRunnerArgv, formatRunnerNotFound, FRAMEWORKS, resolveRunner } from './test-command-runner-resolution.js';
+import { clearCacheAndReport, emitTestFailure, reportRunResult, resolveFramework } from './test-command-run-helpers.js';
 export function runRunner(framework, argv, projectRoot, deps = {}) {
     const resolution = resolveRunner(framework, argv, projectRoot, deps);
     if (!resolution.ok) {
@@ -237,7 +74,7 @@ export function runRunner(framework, argv, projectRoot, deps = {}) {
     });
 }
 export function registerTestCommands(program, _io) {
-    const test = program
+    program
         .command('test')
         .description("Wrap the consumer project's test framework (jest/vitest/mocha) " +
         'with a per-test fingerprint cache. Default args: <pattern...> ' +
@@ -253,91 +90,31 @@ export function registerTestCommands(program, _io) {
         .option('--framework <name>', `force a specific framework: ${FRAMEWORKS.join(', ')}`)
         .option('--project <path>', 'project root (defaults to current directory)', process.cwd())
         .option('--json', 'emit a JSON envelope { ok, data } to stdout')
-        .action(async (patterns, opts) => {
+        .action(async (patterns, options) => {
         try {
-            const projectRoot = resolveCanonicalProjectRoot(opts.project ?? process.cwd());
-            // --clear-cache short-circuit
-            if (opts.clearCache === true) {
-                const result = clearTestCache(projectRoot);
-                if (opts.json === true) {
-                    process.stdout.write(JSON.stringify({
-                        ok: true,
-                        data: { cleared: true, removed: result.removed, dir: '.peaks/_runtime/test-cache/' }
-                    }) + '\n');
-                }
-                else {
-                    process.stdout.write(`cleared ${result.removed} cache file(s) from .peaks/_runtime/test-cache/\n`);
-                }
+            const projectRoot = resolveCanonicalProjectRoot(options.project ?? process.cwd());
+            if (options.clearCache === true) {
+                clearCacheAndReport(options, projectRoot);
                 return;
             }
-            // Framework detection
-            let framework = null;
-            if (opts.framework) {
-                if (!FRAMEWORKS.includes(opts.framework)) {
-                    const msg = `INVALID_FRAMEWORK: --framework must be one of ${FRAMEWORKS.join(', ')} (got "${opts.framework}")`;
-                    if (opts.json === true) {
-                        process.stdout.write(JSON.stringify({ ok: false, error: msg }) + '\n');
-                    }
-                    else {
-                        process.stderr.write(msg + '\n');
-                    }
-                    process.exitCode = 1;
-                    return;
-                }
-                framework = opts.framework;
-            }
-            else {
-                framework = detectTestFramework(projectRoot);
-            }
-            if (!framework) {
-                const msg = 'NO_TEST_FRAMEWORK: no supported test framework found in package.json (jest, vitest, or mocha). Install one and re-run, or pass --framework <name>.';
-                if (opts.json === true) {
-                    process.stdout.write(JSON.stringify({ ok: false, error: msg }) + '\n');
-                }
-                else {
-                    process.stderr.write(msg + '\n');
-                }
-                process.exitCode = 1;
+            const framework = resolveFramework(options, projectRoot);
+            if (framework === null)
                 return;
-            }
             // Pattern argument: --all clears the list, --changed adds --changedSince
-            const effectivePatterns = opts.all ? [] : patterns;
-            const argv = buildRunnerArgv(framework, effectivePatterns, {
-                all: opts.all === true,
-                changed: opts.changed === true,
-                cache: opts.cache === true,
-                passthrough: opts.passthrough === true
+            const argv = buildRunnerArgv(framework, options.all ? [] : patterns, {
+                all: options.all === true,
+                changed: options.changed === true,
+                cache: options.cache === true,
+                passthrough: options.passthrough === true
             });
-            // Stream the runner's output to the user.
-            const result = await runRunner(framework, argv, projectRoot);
-            if (result.notice !== null)
-                process.stderr.write(result.notice);
-            process.stdout.write(result.stdout);
-            process.stderr.write(result.stderr);
-            if (result.code !== 0) {
-                process.exitCode = 1;
-            }
-            if (opts.json === true) {
-                process.stdout.write(JSON.stringify({
-                    ok: result.code === 0,
-                    data: {
-                        framework,
-                        argv,
-                        exitCode: result.code,
-                        fingerprintCache: opts.noCacheResult ? 'bypassed' : 'enabled',
-                        cacheDir: '.peaks/_runtime/test-cache/'
-                    }
-                }) + '\n');
-            }
+            reportRunResult(options, framework, argv, await runRunner(framework, argv, projectRoot));
         }
         catch (error) {
-            if (opts.json === true) {
-                process.stdout.write(JSON.stringify({ ok: false, error: getErrorMessage(error) }) + '\n');
-            }
-            else {
-                process.stderr.write(getErrorMessage(error) + '\n');
-            }
-            process.exitCode = 1;
+            emitTestFailure(options, getErrorMessage(error));
         }
     });
 }
+// Re-export for tests / external consumers: the runner resolver is driven
+// directly (with injected fs / spawn / platform seams) by
+// `tests/unit/cli/commands/test-commands-runner-resolution.test.ts`.
+export { buildRunnerArgv, formatRunnerNotFound, resolveRunner } from './test-command-runner-resolution.js';

package/dist/cli/commands/vm-command-shared.d.ts

@@ -0,0 +1,23 @@
+import { type VmHypervisor } from '../../services/vm/vm-lease.js';
+export type VmOptions = {
+    session?: string;
+    project?: string;
+    json?: boolean;
+};
+export type SpawnOptions = VmOptions & {
+    rid: string;
+    role: string;
+    purpose: string;
+    hypervisor?: VmHypervisor;
+    image?: string;
+    ttl?: string;
+    mount?: string;
+};
+export type ReleaseOptions = VmOptions & {
+    leaseId: string;
+};
+/** `--session`, else `PEAKS_SESSION_ID`, else the project's bound session, else `unknown-sid`. */
+export declare function resolveVmSessionId(projectRoot: string, session: string | undefined): string;
+/** `<projectRoot>/.peaks/_runtime/<sessionId>` — trailing separators collapsed. */
+export declare function joinPathSession(projectRoot: string, sessionId: string): string;
+export declare function resolveTtlMs(raw: string | undefined, role: string): number;

package/dist/cli/commands/vm-command-shared.js

@@ -0,0 +1,23 @@
+// src/cli/commands/vm-command-shared.ts
+//
+// What `peaks vm` verbs share: the option shapes, the session-id resolution and
+// the role-aware TTL. Split out of `vm-commands.ts`; every resolution order and
+// default is unchanged.
+import { getCurrentSessionId } from '../../services/skills/skill-presence-service.js';
+import { ttlForVmRole } from '../../services/vm/vm-lease.js';
+/** `--session`, else `PEAKS_SESSION_ID`, else the project's bound session, else `unknown-sid`. */
+export function resolveVmSessionId(projectRoot, session) {
+    return (session ?? process.env.PEAKS_SESSION_ID ?? getCurrentSessionId(projectRoot) ?? 'unknown-sid');
+}
+/** `<projectRoot>/.peaks/_runtime/<sessionId>` — trailing separators collapsed. */
+export function joinPathSession(projectRoot, sessionId) {
+    return `${projectRoot.replace(/[\\/]+$/, '')}/.peaks/_runtime/${sessionId}`;
+}
+export function resolveTtlMs(raw, role) {
+    if (typeof raw !== 'string' || raw.length === 0)
+        return ttlForVmRole(role);
+    const parsed = Number.parseInt(raw, 10);
+    if (!Number.isInteger(parsed) || parsed <= 0)
+        return ttlForVmRole(role);
+    return parsed;
+}

package/dist/cli/commands/vm-commands.d.ts

@@ -1,30 +1,3 @@
-/**
- *
- * L4 VM isolation runtime. Parallels the design of
- * `container-commands.ts` (Part 12, docker) and
- * `worktree-auth-commands.ts` (Part 1-2, git worktree).
- *
- * Hypervisor dispatch:
- *   - `kvm`      : `virsh create` + `virsh destroy` (Linux KVM via libvirt)
- *   - `hyperkit` : `hvftool create` + `hvftool stop` (macOS HyperKit)
- *   - `hyperv`   : `hvc create` + `hvftool stop` (Windows Hyper-V via
- *     the operator-installed `hvc` shim)
- *
- * The runtime check: which hypervisor binary is on PATH +
- * (for kvm) whether the host kernel exposes /dev/kvm. The
- * spawn is fail-fast: if the requested hypervisor is not
- * available, the CLI returns VM_RUNTIME_UNAVAILABLE with a
- * remediation hint rather than falling through to a different
- * hypervisor (the caller chose a specific mode for a reason).
- *
- * Each spawned VM runs `sleep infinity` as the entrypoint; the
- * VM's working dir is mounted from the host path, and the
- * `peaks.leaseId` / `peaks.rid` labels are propagated via
- * cloud-init metadata. Real workloads are expected to use
- * `peaks vm exec` (a follow-up rid) to run commands inside
- * the VM; Part 35 ships the lease + spawn/release surface
- * only.
- */
 import type { Command } from 'commander';
-import { type ProgramIO } from '../cli-helpers.js';
+import type { ProgramIO } from '../cli-helpers.js';
 export declare function registerVmCommand(program: Command, io: ProgramIO): void;