@gaia-ai/conductor 0.5.4 → 0.6.0

package/dist/src/cli/upgrade.js

@@ -0,0 +1,143 @@
+import { chmodSync, copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { applyMigrations, CONNECTION_MIGRATIONS, GAIA_CONFIG_SCHEMA_VERSION, readConfigSchemaVersion, stampVersion, stripVersionHeader, } from './config-schema.js';
+import { renderGaiaConfig } from './init.js';
+const GAIA_DIR = '.gaia';
+const DEFAULT_ENGINE = 'conductor.config.js';
+const VARIANT_SUFFIX = '.conductor.config.js';
+const CONNECTION = 'gaia.config.js';
+/** Walk from cwd root-ward to the nearest `.gaia/` dir. */
+function findGaiaDir(cwd) {
+    let dir = resolve(cwd);
+    for (;;) {
+        const g = join(dir, GAIA_DIR);
+        if (existsSync(g))
+            return g;
+        const parent = dirname(dir);
+        if (parent === dir)
+            return undefined;
+        dir = parent;
+    }
+}
+function hasEngineConfig(gaiaDir) {
+    return readdirSync(gaiaDir).some((f) => f === DEFAULT_ENGINE || f.endsWith(VARIANT_SUFFIX));
+}
+function legacyMachinePath(home) {
+    return join(home, '.config', 'conductor', 'conductor.config.machine.js');
+}
+function canonicalMachinePath(home) {
+    return join(home, GAIA_DIR, 'machine.config.js');
+}
+/**
+ * Route a single connection-config `path` against the schema version (GAIA-216).
+ * `label` names the file for the report; `current`/`chain` are injectable for
+ * tests (default to the shipped registry). Never executes the config module —
+ * the decision is a regex read of the header marker.
+ *
+ *   | existing marker        | action                                          |
+ *   | absent (no file)       | seed: render current template, stamp CURRENT    |
+ *   | `== CURRENT`           | kept (byte-identical)                           |
+ *   | `1..CURRENT-1` (stale) | back up `.v<old>.bak`, run chain → stamp CURRENT |
+ *   | `0` (unversioned)      | kept (do not clobber hand edits)                |
+ *   | `> CURRENT` (newer)    | kept (refuse to downgrade)                       |
+ */
+export function runConnectionUpgrade(path, opts = {}) {
+    const dry = opts.dryRun ?? false;
+    const label = opts.label ?? 'connection config';
+    const current = opts.current ?? GAIA_CONFIG_SCHEMA_VERSION;
+    const chain = opts.chain ?? CONNECTION_MIGRATIONS;
+    if (!existsSync(path)) {
+        if (!dry) {
+            mkdirSync(dirname(path), { recursive: true });
+            writeFileSync(path, renderGaiaConfig(), 'utf8');
+        }
+        return {
+            action: `${dry ? 'would write' : 'wrote'} ${path} (${label}, schema v${current})`,
+            changed: true,
+        };
+    }
+    const version = readConfigSchemaVersion(path);
+    if (version === current) {
+        return {
+            action: `kept ${path} (${label}, schema v${current} — up to date)`,
+            changed: false,
+        };
+    }
+    if (version === 0) {
+        return {
+            action: `kept ${path} (${label}, unversioned — pass --force to regenerate)`,
+            changed: false,
+        };
+    }
+    if (version > current) {
+        return {
+            action: `kept ${path} (${label}, schema v${version} newer than gaia's v${current} — not downgrading)`,
+            changed: false,
+        };
+    }
+    // 1..current-1: migrate via the per-version chain.
+    const steps = chain
+        .filter((m) => m.from >= version && m.to <= current)
+        .map((m) => m.description)
+        .join('; ') || 'regenerate';
+    if (dry) {
+        return {
+            action: `would migrate ${path} schema v${version}→v${current} (steps: ${steps})`,
+            changed: true,
+        };
+    }
+    const original = readFileSync(path, 'utf8');
+    const bak = `${path}.v${version}.bak`;
+    writeFileSync(bak, original, 'utf8');
+    const migrated = applyMigrations(stripVersionHeader(original), version, current, chain);
+    writeFileSync(path, stampVersion(migrated, current), 'utf8');
+    return {
+        action: `migrated ${path} schema v${version}→v${current} (steps: ${steps}; backup ${bak})`,
+        changed: true,
+    };
+}
+/** Run the migration. Pure w.r.t. injected `cwd`/`home`; `dryRun` suppresses writes. */
+export function runUpgrade(opts = {}) {
+    const cwd = opts.cwd ?? process.cwd();
+    const home = opts.home ?? homedir();
+    const dry = opts.dryRun ?? false;
+    const actions = [];
+    let changed = false;
+    // 1. Project connection config (schema-versioned seed/migrate).
+    const gaiaDir = findGaiaDir(cwd);
+    if (gaiaDir !== undefined && hasEngineConfig(gaiaDir)) {
+        const res = runConnectionUpgrade(join(gaiaDir, CONNECTION), {
+            dryRun: dry,
+            label: 'project connection config',
+        });
+        actions.push(res.action);
+        changed = changed || res.changed;
+    }
+    // 2. Machine context move (secret-bearing — never schema-migrated).
+    const legacy = legacyMachinePath(home);
+    const canonical = canonicalMachinePath(home);
+    if (existsSync(canonical)) {
+        actions.push(`kept ${canonical} (machine context already migrated)`);
+    }
+    else if (existsSync(legacy)) {
+        if (!dry) {
+            mkdirSync(dirname(canonical), { recursive: true });
+            copyFileSync(legacy, canonical);
+            chmodSync(canonical, 0o600);
+            // Leave a re-export shim at the legacy path so an un-upgraded config still resolves.
+            writeFileSync(legacy, `// Moved to ${canonical} by \`gaia upgrade\` (GAIA-201).\nexport { default } from '${pathToFileURL(canonical).href}';\n`, 'utf8');
+        }
+        actions.push(`${dry ? 'would move' : 'moved'} ${legacy} → ${canonical} (machine context, 0600 + shim)`);
+        changed = true;
+    }
+    // 3. Home connection config (schema-versioned seed/migrate).
+    const homeRes = runConnectionUpgrade(join(home, GAIA_DIR, CONNECTION), {
+        dryRun: dry,
+        label: 'home connection config',
+    });
+    actions.push(homeRes.action);
+    changed = changed || homeRes.changed;
+    return { actions, alreadyCurrent: !changed };
+}

package/dist/src/cli/version-check.js

@@ -81,8 +81,12 @@ export function updateNotice(current, latest) {
         return null;
     if (!semver.gt(latest, current))
         return null;
+    // Two distinct steps, apt-style: first get the newer CODE, then migrate the
+    // CONFIG. There is no `gaia update` command — the CLI is a global npm package,
+    // so code is updated via npm; `gaia upgrade` then migrates the config shape.
     return (`A new gaia version is available: ${current} → ${latest}\n` +
-        'Run `gaia update` to upgrade.');
+        'Run `npm install -g @gaia-ai/gaia@latest` to update the CLI, ' +
+        'then `gaia upgrade` to migrate your config.');
 }
 const defaultSpawn = (cmd, args) => new Promise((resolve) => {
     const child = spawn(cmd, args, { stdio: 'inherit', shell: false });

package/dist/src/commands/conductor.d.ts

@@ -0,0 +1,33 @@
+import { type ConductorFileConfig, type ConductorLogger, type GaiaCommandHost, type GaiaCommandPlugin, type GaiaExecutor, type GaiaRemote, type GaiaWorkspace, type ResolvedAgent } from '@gaia-ai/core';
+import { Command } from 'commander';
+/** Test seam: inject any subset of dependencies. */
+export interface GaiaCliDeps {
+    remote?: GaiaRemote;
+    executor?: GaiaExecutor;
+    workspace?: GaiaWorkspace;
+    agents?: ResolvedAgent[];
+    config?: ConductorFileConfig;
+    /** Injectable registry fetch for the start-time version check (tests). */
+    fetch?: typeof fetch;
+    /** Host contract (resolveBases); default: this install + cwd. */
+    host?: GaiaCommandHost;
+}
+export declare function parseHerdrJson(output: string, command: string): unknown;
+/**
+ * Start-time auth gate. Returns true if authenticated (session or session-less
+ * provider); otherwise logs a single clear line and returns false.
+ */
+export declare function ensureAuthenticated(config: ConductorFileConfig, logger: ConductorLogger): Promise<boolean>;
+/** Build the `conductor` subcommand tree (lifecycle + registry + init). */
+export declare function createConductorCommand(deps: GaiaCliDeps): Command;
+/** The `conductor` command plugin the host mounts (GAIA-201). It also registers
+ *  the `gaia deployment` batch helper (conductor-scoped: needs remote + project). */
+declare const conductorCommandPlugin: GaiaCommandPlugin;
+export default conductorCommandPlugin;
+/**
+ * Build a standalone program with the conductor command mounted — the test entry
+ * (mirrors what the host does for `gaia conductor …`). `deps` inject fakes.
+ */
+export declare function buildConductorProgram(deps?: GaiaCliDeps): Command;
+/** Parse argv against the conductor program (test entry). */
+export declare function runConductorCli(argv: string[], deps?: GaiaCliDeps): Promise<void>;