@indigoai-us/hq-cli 5.345.180 → 5.345.182

package/dist/hq-cloud-sync-runner/package.json

@@ -1 +1 @@
-{"name":"hq-cli-daemon-sync-runner","type":"module","version":"6.18.105","bundleSha256":"f57aa12671cdfcf08ce39f11ce6885d6e52d5478f2ae77a75d38d79162194ce5","formatVersion":1}
+{"name":"hq-cli-daemon-sync-runner","type":"module","version":"6.18.106","bundleSha256":"ae4c7a7b3040977faff6e9ea7f302bc9e46cf77675347788642e362c3337e3fe","formatVersion":1}

package/dist/lib/bot/fleet-local.d.ts

@@ -99,6 +99,9 @@ export interface FleetLocalBootstrapDeps {
     start?: boolean;
     python?: FleetPython;
 }
+type FleetLocalProfileDeps = Pick<FleetLocalBootstrapDeps, "fleetHome" | "platform"> & {
+    runtimeRoot?: string;
+};
 export interface FleetLocalBootstrapResult {
     profile: string;
     runtime: string;
@@ -133,7 +136,7 @@ export interface FleetLocalRemovalResult {
     credentialsRemoved: number;
 }
 export declare const HQ_FLEET_LOCAL_RELEASE: FleetLocalReleasePin;
-export declare const HQ_FLEET_LOCAL_PUBLIC_KEY = "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEARXr2I8RNcw2c0Ep77XkYGwylresXBFn8dm9pxN2Zq/U=\n-----END PUBLIC KEY-----\n";
+export declare const HQ_FLEET_LOCAL_PUBLIC_KEY = "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEAwi1nsHS34c3m1k/hvuqnk+9nEuv5qCHh7iFB9BN6iMY=\n-----END PUBLIC KEY-----\n";
 export declare function fleetHome(home?: string, env?: NodeJS.ProcessEnv): string;
 export declare function verifyFleetLocalRelease(files: FleetLocalReleaseFiles, release?: FleetLocalReleasePin, publicKey?: string): void;
 export declare function resolveFleetReleaseToken(env?: NodeJS.ProcessEnv): string;
@@ -144,12 +147,13 @@ export declare const FLEET_LOCAL_RUNTIME_DOWNLOAD_TIMEOUT_MS: number;
 export declare function installPinnedFleetLocalDistribution(deps?: FleetLocalInstallDeps): Promise<FleetLocalInstallation>;
 /** The process id the bot's gateway recorded, when its file reads; the caller checks whether it is alive. */
 export declare function fleetLocalGatewayPid(agentUid: string, deps?: Pick<FleetLocalControlDeps, "fleetHome">): number | null;
+export declare function fleetLocalProfileNeedsAdoption(agentUid: string, deps?: Pick<FleetLocalControlDeps, "fleetHome" | "platform">): boolean;
 export declare function controlFleetLocalBot(agentUid: string, action: FleetLocalServiceAction, deps?: FleetLocalControlDeps): Record<string, unknown>;
 export declare function exportFleetLocalMachineCredential(agentUid: string, deps?: FleetLocalControlDeps): BotMachineCreds;
 export declare function fleetLocalPromotionRuntime(agentUid: string, deps?: FleetLocalControlDeps): LocalBotPromotionRuntime;
 export declare function removeFleetLocalBot(agentUid: string, deps?: FleetLocalControlDeps): FleetLocalRemovalResult;
 export declare function authenticateFleetLocalBot(input: FleetLocalAuthInput, deps?: FleetLocalControlDeps): FleetLocalAuthResult;
-export declare function writeFleetLocalProfile(input: FleetLocalProfileInput, deps?: Pick<FleetLocalBootstrapDeps, "fleetHome" | "platform">): string;
+export declare function writeFleetLocalProfile(input: FleetLocalProfileInput, deps?: FleetLocalProfileDeps): string;
 /** The runtime's inbox plugin sends the intro and runs the kickoff once, then stamps this file. */
 export declare function writeFleetLocalFirstStart(profileDir: string, firstStart: {
     intro?: string;
@@ -167,7 +171,7 @@ export declare function refreshFleetLocalInstructions(agentUid: string, systemPr
 /** Moves a fresh machine credential into the bot's secure store and deletes the file. */
 export declare function importFleetLocalMachineCredential(agentUid: string, machineCredentials: string, deps?: FleetLocalControlDeps): void;
 export declare function bootstrapFleetLocalBot(input: FleetLocalProfileInput & {
-    machineCredentials: string;
+    machineCredentials?: string;
 }, deps?: FleetLocalBootstrapDeps): Promise<FleetLocalBootstrapResult>;
 export {};
 //# sourceMappingURL=fleet-local.d.ts.map

package/dist/lib/bot/fleet-local.js

@@ -36,18 +36,18 @@ export function fleetProviderNeedsSignIn(provider) {
 }
 export const HQ_FLEET_LOCAL_RELEASE = {
     repository: "indigoai-us/hq-fleet-local",
-    tag: "v0.4.14",
-    version: "0.4.14",
-    artifact: "hq-fleet-local-0.4.14.zip",
-    artifactSha256: "9ff6ad4f7235988468e1913008c5650f5d064210078d6d20c407b17120310f47",
+    tag: "v0.4.15",
+    version: "0.4.15",
+    artifact: "hq-fleet-local-0.4.15.zip",
+    artifactSha256: "0f7994047e3348d63bc3838f68e3474192e626082eea678e280f7a9308ce5a1e",
     runtimeArtifact: "hq-fleet-runtime-abccac13bd9e.tar",
     runtimeArtifactSha256: "29bcfe718ad7fbd3636afd00623772f2a25bc84c4f6f10d8d57f38e549d528d5",
-    manifestSha256: "88e71a733a5f57089764cbf9947fb88025c2263c5f3d62a2c6f5ab3635538871",
-    signatureSha256: "b892b54d6fcb2aaca86d049d7662fe5549a250d81877d6c529288e79ae1565d9",
+    manifestSha256: "0d8a7970e99dc33ed757b9168d15a484c7db617f1815297ebe9c5a0c42505792",
+    signatureSha256: "a6c2c1245555ea2c64b65c988e73ce74b7ab196d46ec8d83110efac4dd81391b",
     runtimeCommit: "abccac13bd9ea593b24c8cd9c0ba28d5c6050cc9",
 };
 export const HQ_FLEET_LOCAL_PUBLIC_KEY = `-----BEGIN PUBLIC KEY-----
-MCowBQYDK2VwAyEARXr2I8RNcw2c0Ep77XkYGwylresXBFn8dm9pxN2Zq/U=
+MCowBQYDK2VwAyEAwi1nsHS34c3m1k/hvuqnk+9nEuv5qCHh7iFB9BN6iMY=
 -----END PUBLIC KEY-----
 `;
 function digest(value) {
@@ -322,14 +322,83 @@ export async function installPinnedFleetLocalDistribution(deps = {}) {
         engine: engineMetadata(release),
     };
 }
+function profileName(agentUid) {
+    return agentUid.toLowerCase();
+}
 function profileRoot(agentUid, root) {
-    return path.join(root, "profiles", agentUid);
+    const profiles = path.join(root, "profiles");
+    const canonicalName = profileName(agentUid);
+    const canonical = path.join(profiles, canonicalName);
+    if (fs.existsSync(canonical))
+        return canonical;
+    try {
+        const legacy = fs.readdirSync(profiles, { withFileTypes: true })
+            .find((entry) => entry.isDirectory() && entry.name.toLowerCase() === canonicalName);
+        return legacy ? path.join(profiles, legacy.name) : canonical;
+    }
+    catch {
+        return canonical;
+    }
+}
+function adoptLegacyProfileDirectory(agentUid, root) {
+    const profiles = path.join(root, "profiles");
+    const canonicalName = profileName(agentUid);
+    fs.mkdirSync(profiles, { recursive: true, mode: 0o700 });
+    const matches = fs.readdirSync(profiles, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory() && entry.name.toLowerCase() === canonicalName)
+        .map((entry) => entry.name);
+    if (matches.length > 1) {
+        throw expectedError(`HQ Fleet has conflicting profile directories for ${agentUid}.`);
+    }
+    const existing = matches[0];
+    const canonical = path.join(profiles, canonicalName);
+    if (!existing || existing === canonicalName)
+        return canonical;
+    const source = path.join(profiles, existing);
+    const temporary = path.join(profiles, `.adopt-${canonicalName}-${process.pid}-${crypto.randomUUID()}`);
+    fs.renameSync(source, temporary);
+    try {
+        fs.renameSync(temporary, canonical);
+    }
+    catch (error) {
+        fs.renameSync(temporary, source);
+        throw error;
+    }
+    return canonical;
 }
 function venvExecutable(runtimeDir, name, platform) {
     return platform === "win32"
         ? path.join(runtimeDir, "Scripts", `${name}.exe`)
         : path.join(runtimeDir, "bin", name);
 }
+function sharedRuntimeFromMarker(profileDir, root) {
+    try {
+        const marker = JSON.parse(fs.readFileSync(path.join(profileDir, "bootstrap.json"), "utf8"));
+        if (marker.schemaVersion !== 2 || typeof marker.runtimeId !== "string" || !/^[a-f0-9]{64}$/.test(marker.runtimeId))
+            return null;
+        const sharedRoot = path.join(root, "runtimes", marker.runtimeId);
+        return {
+            id: marker.runtimeId,
+            root: sharedRoot,
+            runtimeDir: path.join(sharedRoot, "runtime"),
+            sourcesDir: path.join(sharedRoot, "sources"),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function hasEmbeddedRuntime(profileDir, platform) {
+    const runtimeDir = path.join(profileDir, "runtime");
+    try {
+        if (fs.lstatSync(runtimeDir).isSymbolicLink())
+            return true;
+    }
+    catch {
+        return false;
+    }
+    return ["hq-fleet", "hq-fleet-local"].some((name) => fs.existsSync(venvExecutable(runtimeDir, name, platform)));
+}
 function fleetLocalExecutables(agentUid, deps) {
     if (!/^agt_[A-Za-z0-9_-]+$/.test(agentUid)) {
         throw expectedError(`Cannot use an HQ Fleet profile for invalid bot id ${agentUid}.`);
@@ -337,14 +406,16 @@ function fleetLocalExecutables(agentUid, deps) {
     const root = deps.fleetHome ?? fleetHome();
     const platform = deps.platform ?? process.platform;
     const profileDir = profileRoot(agentUid, root);
-    const runtimeDir = path.join(profileDir, "runtime");
+    const shared = sharedRuntimeFromMarker(profileDir, root);
+    const runtimeDir = shared?.runtimeDir ?? path.join(profileDir, "runtime");
+    const sourcesDir = shared?.sourcesDir ?? path.join(profileDir, "sources");
     const profile = path.join(profileDir, "profile.json");
     const runtime = venvExecutable(runtimeDir, "hq-fleet", platform);
     const helper = venvExecutable(runtimeDir, "hq-fleet-local", platform);
     if (![profile, runtime, helper].every((item) => fs.existsSync(item))) {
         throw expectedError(`HQ Fleet Local is not fully installed for ${agentUid}.`);
     }
-    return { profileDir, profile, runtime, helper };
+    return { profileDir, profile, runtime, helper, runtimeDir, sourcesDir };
 }
 function runJson(run, executable, args, options, label) {
     let output;
@@ -377,10 +448,39 @@ export function fleetLocalGatewayPid(agentUid, deps = {}) {
         return null;
     }
 }
+export function fleetLocalProfileNeedsAdoption(agentUid, deps = {}) {
+    if (!/^agt_[A-Za-z0-9_-]+$/.test(agentUid))
+        return true;
+    const root = deps.fleetHome ?? fleetHome();
+    const profiles = path.join(root, "profiles");
+    const canonicalName = profileName(agentUid);
+    let entries;
+    try {
+        entries = fs.readdirSync(profiles);
+    }
+    catch {
+        return true;
+    }
+    if (!entries.includes(canonicalName))
+        return true;
+    const profileDir = path.join(profiles, canonicalName);
+    const shared = sharedRuntimeFromMarker(profileDir, root);
+    if (!shared)
+        return true;
+    const platform = deps.platform ?? process.platform;
+    if (!["hq-fleet", "hq-fleet-local", "python"].every((name) => fs.existsSync(venvExecutable(shared.runtimeDir, name, platform))))
+        return true;
+    if (hasEmbeddedRuntime(profileDir, platform) || fs.existsSync(path.join(profileDir, "sources")))
+        return true;
+    return false;
+}
 export function controlFleetLocalBot(agentUid, action, deps = {}) {
     const run = deps.run ?? execFileSync;
     const files = fleetLocalExecutables(agentUid, deps);
-    return runJson(run, files.helper, ["service", action, "--profile", files.profileDir, "--runtime", files.runtime], { stdio: ["ignore", "pipe", "pipe"] }, `service ${action}`);
+    const result = runJson(run, files.helper, ["service", action, "--profile", files.profileDir, "--runtime", files.runtime], { stdio: ["ignore", "pipe", "pipe"] }, `service ${action}`);
+    if (action === "install" && result.ok === true)
+        removeEmbeddedRuntime(files.profileDir, deps.platform ?? process.platform);
+    return result;
 }
 const providerProfiles = {
     chatgpt: {
@@ -511,14 +611,15 @@ export function removeFleetLocalBot(agentUid, deps = {}) {
     const profileDir = profileRoot(agentUid, deps.fleetHome ?? fleetHome());
     if (!fs.existsSync(profileDir))
         return { removed: false, credentialsRemoved: 0 };
+    if (!fs.existsSync(path.join(profileDir, "profile.json"))) {
+        fs.rmSync(profileDir, { recursive: true, force: true });
+        return { removed: true, credentialsRemoved: 0 };
+    }
     const platform = deps.platform ?? process.platform;
-    const runtimeDir = path.join(profileDir, "runtime");
-    const partial = ![
-        path.join(profileDir, "profile.json"),
-        venvExecutable(runtimeDir, "hq-fleet", platform),
-        venvExecutable(runtimeDir, "hq-fleet-local", platform),
-    ].every((item) => fs.existsSync(item));
-    if (partial) {
+    const legacyRuntime = path.join(profileDir, "runtime");
+    const shared = sharedRuntimeFromMarker(profileDir, deps.fleetHome ?? fleetHome());
+    const installedRuntime = shared?.runtimeDir ?? legacyRuntime;
+    if (!["hq-fleet", "hq-fleet-local"].every((name) => fs.existsSync(venvExecutable(installedRuntime, name, platform)))) {
         fs.rmSync(profileDir, { recursive: true, force: true });
         return { removed: true, credentialsRemoved: 0 };
     }
@@ -634,7 +735,9 @@ export function writeFleetLocalProfile(input, deps = {}) {
     }
     const root = deps.fleetHome ?? fleetHome();
     const dir = profileRoot(input.agentUid, root);
-    const runtimeDir = path.join(dir, "runtime");
+    const markerRuntime = sharedRuntimeFromMarker(dir, root);
+    const runtimeRoot = deps.runtimeRoot ?? markerRuntime?.root ?? dir;
+    const runtimeDir = path.join(runtimeRoot, "runtime");
     const destination = path.join(dir, "profile.json");
     const temporary = path.join(dir, `.profile-${process.pid}-${crypto.randomUUID()}`);
     const profile = {
@@ -647,7 +750,7 @@ export function writeFleetLocalProfile(input, deps = {}) {
         profileDir: path.resolve(dir),
         runtime: { commit: input.installation.release.runtimeCommit, path: path.resolve(runtimeDir) },
         paths: {
-            pluginSource: path.resolve(path.join(dir, "sources", "distribution", "src", "hq_fleet_local", "plugins", "hqdm")),
+            pluginSource: path.resolve(path.join(runtimeRoot, "sources", "distribution", "src", "hq_fleet_local", "plugins", "hqdm")),
             statusFile: path.resolve(path.join(input.botDir, "status.json")),
             logsDir: path.resolve(path.join(input.botDir, "logs")),
         },
@@ -706,9 +809,13 @@ export function scanFleetLocalInstructions(agentUid, text, deps = {}) {
         throw expectedError(`Cannot use an HQ Fleet profile for invalid bot id ${agentUid}.`);
     }
     const run = deps.run ?? execFileSync;
-    const profileDir = profileRoot(agentUid, deps.fleetHome ?? fleetHome());
-    const python = venvExecutable(path.join(profileDir, "runtime"), "python", deps.platform ?? process.platform);
-    const source = path.join(profileDir, "sources", "runtime");
+    const root = deps.fleetHome ?? fleetHome();
+    const profileDir = profileRoot(agentUid, root);
+    const shared = sharedRuntimeFromMarker(profileDir, root);
+    const runtimeDir = shared?.runtimeDir ?? path.join(profileDir, "runtime");
+    const sourcesDir = shared?.sourcesDir ?? path.join(profileDir, "sources");
+    const python = venvExecutable(runtimeDir, "python", deps.platform ?? process.platform);
+    const source = path.join(sourcesDir, "runtime");
     if (!fs.existsSync(python) || !fs.existsSync(source)) {
         throw expectedError("HQ Fleet Local is not installed for this bot, so its instructions could not be checked.");
     }
@@ -774,6 +881,12 @@ async function installSharedFleetRuntime(installation, root, python, platform, r
         extras: ["mcp", "anthropic"],
     })));
     const shared = path.join(root, "runtimes", identity);
+    const descriptor = () => ({
+        id: identity,
+        root: shared,
+        runtimeDir: path.join(shared, "runtime"),
+        sourcesDir: path.join(shared, "sources"),
+    });
     return withBotLock(identity, async () => {
         const marker = path.join(shared, "ready.json");
         const sources = path.join(shared, "sources");
@@ -785,7 +898,7 @@ async function installSharedFleetRuntime(installation, root, python, platform, r
             if (!executables.every((name) => fs.existsSync(venvExecutable(runtimeDir, name, platform)))) {
                 throw expectedError("The shared HQ Fleet Runtime is incomplete. Reinstall it before creating another bot.");
             }
-            return shared;
+            return descriptor();
         }
         fs.rmSync(shared, { recursive: true, force: true });
         fs.mkdirSync(distributionSource, { recursive: true, mode: 0o700 });
@@ -827,54 +940,59 @@ async function installSharedFleetRuntime(installation, root, python, platform, r
             throw expectedError("HQ Fleet Local installed without its runtime executables.");
         }
         fs.writeFileSync(marker, `${JSON.stringify({ schemaVersion: 1, engine: installation.engine })}\n`, { mode: 0o600 });
-        return shared;
+        return descriptor();
     }, { root: path.join(root, "runtimes"), command: "HQ Fleet Runtime installation", waitMs: 20 * 60_000, staleMs: 2 * 60 * 60_000 });
 }
+function writeNativeProfileMarker(profileDir, shared, engine) {
+    const marker = path.join(profileDir, "bootstrap.json");
+    const temporary = `${marker}.${process.pid}.${crypto.randomUUID()}`;
+    fs.writeFileSync(temporary, `${JSON.stringify({ schemaVersion: 2, runtimeId: shared.id, engine }, null, 2)}\n`, { mode: 0o600 });
+    fs.renameSync(temporary, marker);
+}
+function removeEmbeddedRuntime(profileDir, platform = process.platform) {
+    fs.rmSync(path.join(profileDir, "sources"), { recursive: true, force: true });
+    if (hasEmbeddedRuntime(profileDir, platform))
+        fs.rmSync(path.join(profileDir, "runtime"), { recursive: true, force: true });
+}
 export async function bootstrapFleetLocalBot(input, deps = {}) {
     const run = deps.run ?? execFileSync;
     const platform = deps.platform ?? process.platform;
     const root = deps.fleetHome ?? fleetHome();
     const python = deps.python ?? await ensureFleetPython({ fleetHome: root, platform, run });
-    const profileDir = profileRoot(input.agentUid, root);
-    const runtimeDir = path.join(profileDir, "runtime");
-    const marker = path.join(profileDir, "bootstrap.json");
+    const profileDir = adoptLegacyProfileDirectory(input.agentUid, root);
     fs.mkdirSync(profileDir, { recursive: true, mode: 0o700 });
-    if (!fs.existsSync(marker)) {
-        const shared = await installSharedFleetRuntime(input.installation, root, python, platform, run);
-        for (const name of ["sources", "runtime"]) {
-            const target = path.join(profileDir, name);
-            fs.rmSync(target, { recursive: true, force: true });
-            fs.symlinkSync(path.join(shared, name), target, platform === "win32" ? "junction" : "dir");
-        }
-        fs.writeFileSync(marker, `${JSON.stringify({ schemaVersion: 1, engine: input.installation.engine }, null, 2)}\n`, { mode: 0o600 });
-    }
-    const { systemPrompt, ...profileInput } = input;
+    const shared = await installSharedFleetRuntime(input.installation, root, python, platform, run);
+    writeNativeProfileMarker(profileDir, shared, input.installation.engine);
+    const { systemPrompt, machineCredentials, ...profileInput } = input;
     if (systemPrompt !== undefined)
         refreshFleetLocalInstructions(input.agentUid, systemPrompt, { fleetHome: root, platform, run });
-    const profile = writeFleetLocalProfile(profileInput, { fleetHome: root, platform });
-    const helper = venvExecutable(runtimeDir, "hq-fleet-local", platform);
-    const runtime = venvExecutable(runtimeDir, "hq-fleet", platform);
+    const profile = writeFleetLocalProfile(profileInput, { fleetHome: root, platform, runtimeRoot: shared.root });
+    const helper = venvExecutable(shared.runtimeDir, "hq-fleet-local", platform);
+    const runtime = venvExecutable(shared.runtimeDir, "hq-fleet", platform);
     if (!fs.existsSync(helper) || !fs.existsSync(runtime)) {
         throw expectedError("HQ Fleet Local installed without its runtime executables.");
     }
     checkedRun(run, helper, ["render-profile", "--spec", profile, "--mode", "create"], { stdio: "ignore" }, "profile rendering");
-    const machineValue = fs.readFileSync(input.machineCredentials, "utf8").trim();
-    if (!machineValue) {
-        throw expectedError(`HQ Fleet Local machine credential file is empty: ${input.machineCredentials}`);
+    if (machineCredentials) {
+        const machineValue = fs.readFileSync(machineCredentials, "utf8").trim();
+        if (!machineValue) {
+            throw expectedError(`HQ Fleet Local machine credential file is empty: ${machineCredentials}`);
+        }
+        checkedRun(run, helper, [
+            "machine-credential",
+            "import",
+            "--profile",
+            profileDir,
+            "--bot-id",
+            input.agentUid,
+        ], { input: machineValue, stdio: ["pipe", "ignore", "pipe"] }, "machine credential import");
+        fs.rmSync(machineCredentials, { force: true });
     }
-    checkedRun(run, helper, [
-        "machine-credential",
-        "import",
-        "--profile",
-        profileDir,
-        "--bot-id",
-        input.agentUid,
-    ], { input: machineValue, stdio: ["pipe", "ignore", "pipe"] }, "machine credential import");
-    fs.rmSync(input.machineCredentials, { force: true });
     checkedRun(run, helper, ["doctor-profile", "--profile", profileDir, "--runtime", runtime], { stdio: "ignore" }, "profile validation");
     const start = deps.start !== false;
     if (start) {
         checkedRun(run, helper, ["service", "install", "--profile", profileDir, "--runtime", runtime], { stdio: ["ignore", 2, 2] }, "service installation");
+        removeEmbeddedRuntime(profileDir, platform);
     }
     return { profile, runtime, helper, running: start };
 }