@indigoai-us/hq-cli 5.345.122 → 5.345.124

package/dist/commands/core-bucket-c-handoff-sync-native.js

@@ -0,0 +1,300 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { buildSpawnPlan } from "../utils/windows-spawn.js";
+export const HANDOFF_SYNC_PREFETCH_ASSET = "core/scripts/handoff-sync-prefetch.sh";
+export const HANDOFF_SYNC_PUBLISH_ASSET = "core/scripts/handoff-sync-publish.sh";
+const PREFETCH_HELP = [
+    "!/bin/bash",
+    "handoff-sync-prefetch.sh - pull the latest session continuity pointer before",
+    "a fresh session reads it.",
+    "",
+    "`/startwork` and `/resumework` both read `workspace/threads/handoff.json`",
+    "(and the thread file it references) to decide what to resume. On a second",
+    "device those files only exist after a vault pull has landed, so a naive",
+    "resume right after sign-in sees stale state. This helper runs that pull",
+    "BEFORE the skill reads the pointer.",
+    "",
+    "Fail-soft:",
+    "  - no-op when the `hq` CLI is missing",
+    "  - no-op when offline or not logged in",
+    "  - timeboxed (default 25s)",
+    "  - never fails the caller: a successful or failed pull are both exit 0;",
+    "    the caller falls through to the local pointer either way.",
+    "",
+    "Usage:",
+    "  handoff-sync-prefetch.sh [--hq-root PATH] [--timeout SECONDS] [--log PATH]",
+    "",
+    "Prints one line of status on stdout for the caller to echo (or ignore):",
+    "  `ok`           - pull completed within the timeout",
+    "  `missing-cli`  - `hq` is not on PATH; nothing was attempted",
+    "  `skipped`      - CLI is present but the pull refused to start (no login,",
+    "                   locked, etc.); local pointer is still used",
+    "  `timed-out`    - pull exceeded the timeout and was killed",
+    "  `error:<rc>`   - pull returned a non-zero exit code",
+    "",
+    "Exits 0 in every case so a shell `|| true` is unnecessary at call sites.",
+    "",
+].join("\n");
+const PUBLISH_HELP = [
+    "!/bin/bash",
+    "handoff-sync-publish.sh - push the session continuity pointer to the personal vault.",
+    "",
+    "Cross-device handoff depends on `workspace/threads/handoff.json` and the",
+    "single thread file it points to reaching the vault before a fresh session on",
+    "another machine runs `/startwork` or `/resumework`. The workspace tree is",
+    "otherwise machine-local (`PERSONAL_VAULT_EXCLUDED_TOP_LEVEL`), so without a",
+    "push run between the two sessions machine B sees stale state or no handoff",
+    "at all. See hq-cloud-sync `computeContinuityPointerPaths`.",
+    "",
+    "This helper is intentionally minimal and fail-soft:",
+    "  - no-op when the `hq` CLI is missing (fresh install, agent box without CLI)",
+    "  - no-op when offline or not logged in (vault push will fail; we never",
+    "    block /handoff on cloud reachability)",
+    "  - timeboxed (default 25s) so a slow network cannot stall session end",
+    "  - detached by default; the handoff-finalize payload is already emitted",
+    "",
+    "Usage:",
+    "  handoff-sync-publish.sh [--hq-root PATH] [--timeout SECONDS]",
+    "                         [--sync] [--log PATH]",
+    "",
+    "  --sync     Run synchronously in the foreground and return the exit code.",
+    "             Default behaviour forks a backgrounded worker and prints its PID.",
+    "  --timeout  Wall-clock bound in seconds; the push is killed on expiry.",
+    "  --log      Append combined stdout/stderr to this path (default: `/tmp/handoff-sync-publish.log`).",
+    "",
+    "Exits 0 on dispatch (background mode) or on push success (sync mode).",
+    "A sync-mode failure returns the underlying `hq` exit, or 124 on timeout.",
+    "",
+].join("\n");
+const result = (code, stdout = "", stderr = "") => ({ code, stdout, stderr });
+const fail = (message, code = 1) => result(code, "", message + "\n");
+const defaults = () => ({ spawn: (command, args, options) => spawn(command, args, options), cwd: process.cwd(), env: process.env, pid: process.pid, now: () => new Date() });
+function parseArgs(args, kind, env = process.env) {
+    let root = "";
+    let timeout = kind === "prefetch"
+        ? (env.HQ_HANDOFF_PREFETCH_TIMEOUT ?? "25")
+        : (env.HQ_HANDOFF_PUBLISH_TIMEOUT ?? "25");
+    let log = kind === "prefetch" ? "/tmp/handoff-sync-prefetch.log" : "/tmp/handoff-sync-publish.log";
+    let sync = false;
+    let child = false;
+    for (let index = 0; index < args.length;) {
+        const token = args[index];
+        if (token === "--hq-root" || token === "--timeout" || token === "--log") {
+            if (index + 1 >= args.length) {
+                const script = kind === "prefetch" ? "handoff-sync-prefetch.sh" : "handoff-sync-publish.sh";
+                const line = kind === "prefetch"
+                    ? { "--hq-root": 39, "--timeout": 40, "--log": 41 }[token]
+                    : { "--hq-root": 39, "--timeout": 40, "--log": 42 }[token];
+                const scriptPath = shellScriptPath(fileURLToPath(new URL(`../../assets/scaffold/core/scripts/${script}`, import.meta.url)));
+                return result(1, "", `${scriptPath}: line ${line}: $2: unbound variable\n`);
+            }
+            const value = args[index + 1];
+            if (token === "--hq-root")
+                root = value;
+            else if (token === "--timeout")
+                timeout = value;
+            else
+                log = value;
+            index += 2;
+            continue;
+        }
+        if (token === "--sync" && kind === "publish") {
+            sync = true;
+            index += 1;
+            continue;
+        }
+        if (token === "--child" && kind === "publish") {
+            sync = true;
+            child = true;
+            index += 1;
+            continue;
+        }
+        if (token === "-h" || token === "--help")
+            return result(0, `${kind === "prefetch" ? PREFETCH_HELP : PUBLISH_HELP}\n`);
+        return fail(`handoff-sync-${kind}: unknown arg: ${token}`, 2);
+    }
+    return { root, timeout, log, sync, child };
+}
+function shellScriptPath(value) {
+    if (process.platform !== "win32")
+        return value;
+    const normalized = value.replaceAll("\\", "/");
+    const drivePath = normalized.match(/^([A-Za-z]):\/(.*)$/);
+    return drivePath ? `/${drivePath[1].toLowerCase()}/${drivePath[2]}` : normalized;
+}
+function exitCode(code, signal) {
+    if (code !== null)
+        return code;
+    if (signal === "SIGTERM")
+        return 143;
+    if (signal === "SIGKILL")
+        return 137;
+    return 1;
+}
+function runWithTimeout(deps, logFd, timeoutText, args) {
+    return new Promise((resolve) => {
+        let child;
+        try {
+            const plan = buildSpawnPlan("hq", args);
+            child = deps.spawn(plan.cmd, plan.args, {
+                cwd: deps.cwd, env: deps.env, stdio: ["ignore", logFd, logFd], windowsHide: true,
+                shell: plan.shell,
+                ...(plan.windowsVerbatimArguments ? { windowsVerbatimArguments: true } : {}),
+            });
+        }
+        catch {
+            fs.writeSync(logFd, "spawn hq failed\n");
+            resolve({ code: 127, timedOut: false });
+            return;
+        }
+        const seconds = Number(timeoutText);
+        let timedOut = false;
+        let killTimer;
+        let timeoutTimer;
+        if (Number.isFinite(seconds)) {
+            timeoutTimer = setTimeout(() => {
+                timedOut = true;
+                child.kill("SIGTERM");
+                killTimer = setTimeout(() => child.kill("SIGKILL"), 1000);
+            }, Math.max(0, seconds) * 1000);
+            timeoutTimer.unref();
+        }
+        child.once("error", () => {
+            if (timeoutTimer)
+                clearTimeout(timeoutTimer);
+            if (killTimer)
+                clearTimeout(killTimer);
+            fs.writeSync(logFd, "hq: command not found\n");
+            resolve({ code: 127, timedOut });
+        });
+        child.once("exit", (code, signal) => {
+            if (timeoutTimer)
+                clearTimeout(timeoutTimer);
+            if (killTimer)
+                clearTimeout(killTimer);
+            resolve({ code: exitCode(code, signal), timedOut });
+        });
+    });
+}
+function openLog(log) {
+    try {
+        fs.mkdirSync(path.dirname(log), { recursive: true });
+    }
+    catch { /* the shell ignores mkdir failure */ }
+    try {
+        return fs.openSync(log, "a");
+    }
+    catch (cause) {
+        return fail(String(cause.message));
+    }
+}
+function header(deps, root, kind, timeout, mode = "") {
+    return `\n--- handoff-sync-${kind} ${deps.now().toISOString().replace(/\.\d{3}Z$/, "Z")} hq_root=${root} ${mode ? `mode=${mode} ` : ""}timeout=${timeout}s ---\n`;
+}
+function resolveRoot(root, deps) {
+    return root || (deps.env.HQ_ROOT ?? deps.cwd);
+}
+function commandOnPath(name, env) {
+    const pathKey = Object.keys(env).find((key) => key.toUpperCase() === "PATH");
+    const searchPath = pathKey ? env[pathKey] ?? "" : "";
+    const windows = process.platform === "win32";
+    const pathExtKey = Object.keys(env).find((key) => key.toUpperCase() === "PATHEXT");
+    const extensions = windows
+        ? (pathExtKey ? env[pathExtKey] ?? ".COM;.EXE;.BAT;.CMD" : ".COM;.EXE;.BAT;.CMD").split(";")
+        : [""];
+    const names = windows && path.extname(name) ? [name] : extensions.map((extension) => `${name}${extension}`);
+    for (const directory of searchPath.split(path.delimiter)) {
+        for (const executable of names) {
+            try {
+                const target = path.join(directory || ".", executable);
+                fs.accessSync(target, windows ? fs.constants.F_OK : fs.constants.X_OK);
+                if (fs.statSync(target).isFile())
+                    return true;
+            }
+            catch {
+                // command -v advances through the path when an entry is absent or unusable.
+            }
+        }
+    }
+    return false;
+}
+export async function runHandoffSyncPrefetch(args, hqRoot, deps = defaults()) {
+    const parsed = parseArgs(args, "prefetch", deps.env);
+    if ("code" in parsed)
+        return parsed;
+    if (!commandOnPath("hq", deps.env))
+        return result(0, "missing-cli\n");
+    const root = resolveRoot(parsed.root || hqRoot, deps);
+    const fd = openLog(parsed.log);
+    if (typeof fd !== "number")
+        return fd;
+    try {
+        fs.writeSync(fd, header(deps, root, "prefetch", parsed.timeout));
+        const run = await runWithTimeout(deps, fd, parsed.timeout, ["sync", "pull", "--personal", "--hq-root", root, "--lock-timeout", "0"]);
+        fs.writeSync(fd, `exit=${run.timedOut ? 124 : run.code}\n`);
+        const text = fs.readFileSync(parsed.log, "utf8");
+        if (run.timedOut)
+            return result(0, "timed-out\n");
+        if (run.code === 0)
+            return result(0, "ok\n");
+        return result(0, /not logged in|no cached session|refused immediately|requires login/i.test(text) ? "skipped\n" : `error:${run.code}\n`);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+export async function runHandoffSyncPublish(args, hqRoot, deps = defaults()) {
+    const parsed = parseArgs(args, "publish", deps.env);
+    if ("code" in parsed)
+        return parsed;
+    if (!commandOnPath("hq", deps.env))
+        return result(0);
+    const root = resolveRoot(parsed.root || hqRoot, deps);
+    const fd = openLog(parsed.log);
+    if (typeof fd !== "number")
+        return fd;
+    if (!parsed.child)
+        fs.writeSync(fd, header(deps, root, "publish", parsed.timeout, parsed.sync ? "sync" : "background"));
+    if (!parsed.sync) {
+        fs.closeSync(fd);
+        let output;
+        try {
+            output = fs.openSync(parsed.log, "a");
+        }
+        catch (cause) {
+            return fail(String(cause.message));
+        }
+        let child;
+        try {
+            const args = ["core", "--hq-root", root, "handoff-sync-publish", "--timeout", parsed.timeout, "--log", parsed.log, "--child"];
+            const plan = buildSpawnPlan("hq", args);
+            child = deps.spawn(plan.cmd, plan.args, {
+                cwd: deps.cwd, env: deps.env, detached: true, windowsHide: true, stdio: ["ignore", output, output],
+                shell: plan.shell,
+                ...(plan.windowsVerbatimArguments ? { windowsVerbatimArguments: true } : {}),
+            });
+        }
+        catch {
+            if (typeof output === "number")
+                fs.closeSync(output);
+            return fail("handoff-sync-publish: failed to detach hq");
+        }
+        fs.closeSync(output);
+        return new Promise((resolve) => {
+            child.once("spawn", () => { child.unref(); resolve(result(0, `${child.pid ?? 0}\n`)); });
+            child.once("error", () => resolve(result(0, `${child.pid ?? 0}\n`)));
+        });
+    }
+    try {
+        const run = await runWithTimeout(deps, fd, parsed.timeout, ["sync", "push", "--personal", "--hq-root", root, "--lock-timeout", "0", "--message", "handoff continuity pointer"]);
+        fs.writeSync(fd, `exit=${run.timedOut ? 124 : run.code}\n`);
+        return result(run.timedOut ? 124 : run.code);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+export const __handoffSyncTest = { parseArgs, exitCode, runWithTimeout, openLog, header, resolveRoot, commandOnPath };
+//# sourceMappingURL=core-bucket-c-handoff-sync-native.js.map

package/dist/commands/core-bucket-c-small-fast.d.ts

@@ -0,0 +1,5 @@
+import { KNOWLEDGE_PULSE_LOCK_ASSET, runKnowledgePulseLock, runSkillInstalled, SKILL_INSTALLED_ASSET } from "./core-bucket-c-small-native.js";
+export { KNOWLEDGE_PULSE_LOCK_ASSET, SKILL_INSTALLED_ASSET, runKnowledgePulseLock, runSkillInstalled };
+export declare function runKnowledgePulseLockFast(args: string[], _stdin: string, _cwd: string, _root: string): number;
+export declare function runSkillInstalledFast(args: string[], _stdin: string, _cwd: string, root: string): Promise<number>;
+//# sourceMappingURL=core-bucket-c-small-fast.d.ts.map

package/dist/commands/core-bucket-c-small-fast.js

@@ -0,0 +1,19 @@
+import { KNOWLEDGE_PULSE_LOCK_ASSET, runKnowledgePulseLock, runSkillInstalled, SKILL_INSTALLED_ASSET } from "./core-bucket-c-small-native.js";
+export { KNOWLEDGE_PULSE_LOCK_ASSET, SKILL_INSTALLED_ASSET, runKnowledgePulseLock, runSkillInstalled };
+export function runKnowledgePulseLockFast(args, _stdin, _cwd, _root) {
+    const result = runKnowledgePulseLock(args);
+    if (result.stdout)
+        process.stdout.write(result.stdout);
+    if (result.stderr)
+        process.stderr.write(result.stderr);
+    return result.code;
+}
+export async function runSkillInstalledFast(args, _stdin, _cwd, root) {
+    const result = await runSkillInstalled(args, root);
+    if (result.stdout)
+        process.stdout.write(result.stdout);
+    if (result.stderr)
+        process.stderr.write(result.stderr);
+    return result.code;
+}
+//# sourceMappingURL=core-bucket-c-small-fast.js.map

package/dist/commands/core-bucket-c-small-native.d.ts

@@ -0,0 +1,11 @@
+export declare const KNOWLEDGE_PULSE_LOCK_ASSET = "core/scripts/knowledge-pulse-lock.sh";
+export declare const SKILL_INSTALLED_ASSET = "core/scripts/skill-installed.sh";
+export type BucketCSmallResult = {
+    code: number;
+    stdout: string;
+    stderr: string;
+};
+export declare function mkdirFailure(error: unknown, target: string, platform?: NodeJS.Platform): string;
+export declare function runKnowledgePulseLock(args: readonly string[]): BucketCSmallResult;
+export declare function runSkillInstalled(args: readonly string[], root: string, env?: NodeJS.ProcessEnv): Promise<BucketCSmallResult>;
+//# sourceMappingURL=core-bucket-c-small-native.d.ts.map

package/dist/commands/core-bucket-c-small-native.js

@@ -0,0 +1,197 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+export const KNOWLEDGE_PULSE_LOCK_ASSET = "core/scripts/knowledge-pulse-lock.sh";
+export const SKILL_INSTALLED_ASSET = "core/scripts/skill-installed.sh";
+const failure = (stderr, code = 1) => ({ code, stdout: "", stderr: `${stderr}\n` });
+export function mkdirFailure(error, target, platform = process.platform) {
+    const fsError = error;
+    // Node's Windows fs wrapper may report this ENOTDIR as code UNKNOWN, errno -20.
+    let code = platform === "win32" && fsError.errno === -20 ? "ENOTDIR" : fsError.code;
+    const absolute = path.resolve(target);
+    const parsed = path.parse(absolute);
+    const parts = absolute.slice(parsed.root.length).split(path.sep).filter(Boolean);
+    if (platform === "win32" && parts.some((part) => part.length > 255))
+        code = "ENAMETOOLONG";
+    const reason = {
+        EACCES: "Permission denied",
+        EEXIST: "File exists",
+        ELOOP: "Too many levels of symbolic links",
+        EMFILE: "Too many open files",
+        ENAMETOOLONG: "File name too long",
+        ENFILE: "Too many open files in system",
+        ENOENT: "No such file or directory",
+        ENOMEM: "Cannot allocate memory",
+        ENOSPC: "No space left on device",
+        ENOTDIR: "Not a directory",
+        EPERM: "Operation not permitted",
+        EROFS: "Read-only file system",
+    }[code ?? ""] ?? "Input/output error";
+    let failingPath = target;
+    if (code === "ENOTDIR" || code === "ELOOP" || code === "ENAMETOOLONG") {
+        let current = parsed.root;
+        for (const part of parts) {
+            current = path.join(current, part);
+            if (platform === "win32" && part.length > 255) {
+                failingPath = current;
+                break;
+            }
+            try {
+                if (!fs.statSync(current).isDirectory()) {
+                    failingPath = current;
+                    break;
+                }
+            }
+            catch (error) {
+                if (error.code === code)
+                    failingPath = current;
+                break;
+            }
+        }
+    }
+    if (platform === "darwin")
+        return `mkdir: ${failingPath}: ${reason}`;
+    if (platform === "win32") {
+        const shellPathParts = path.parse(failingPath);
+        // MSYS converts the incoming drive path for mkdir, retaining Node's root slash and adding its own.
+        const driveRoot = shellPathParts.root.endsWith("\\") ? `${shellPathParts.root}\\` : shellPathParts.root;
+        const shellPath = `${driveRoot}${failingPath.slice(shellPathParts.root.length).replaceAll("\\", "/")}`;
+        return `mkdir: cannot create directory '${shellPath}': ${reason}`;
+    }
+    return `mkdir: cannot create directory ‘${failingPath}’: ${reason}`;
+}
+export function runKnowledgePulseLock(args) {
+    if (args.length !== 4 || args[0] !== "claim") {
+        return failure("Usage: knowledge-pulse-lock.sh claim <claim-root> <company-slug> <YYYY-MM-DD>", 2);
+    }
+    const [_, claimRoot, company, date] = args;
+    if (!claimRoot || !/^[a-z0-9][a-z0-9-]*$/.test(company) || !/^\d{4}-\d{2}-\d{2}$/.test(date)) {
+        return failure("knowledge-pulse-lock: invalid claim root, company slug, or date", 2);
+    }
+    try {
+        fs.mkdirSync(claimRoot, { recursive: true });
+    }
+    catch (error) {
+        return failure(mkdirFailure(error, claimRoot));
+    }
+    const marker = path.join(claimRoot, `${company}-${date}.claimed`);
+    try {
+        fs.mkdirSync(marker);
+        return { code: 0, stdout: "claimed\n", stderr: "" };
+    }
+    catch (error) {
+        if (error.code === "EEXIST") {
+            try {
+                if (fs.statSync(marker).isDirectory())
+                    return { code: 0, stdout: "already-claimed\n", stderr: "" };
+            }
+            catch { /* fall through to the shell-compatible failure */ }
+        }
+        return failure("knowledge-pulse-lock: could not create claim marker");
+    }
+}
+function skillName(file) {
+    try {
+        if (!fs.statSync(file).isFile())
+            return undefined;
+        const contents = fs.readFileSync(file, "utf8");
+        const lines = (process.platform === "win32" ? contents.replaceAll("\r\n", "\n") : contents).split("\n");
+        let inFrontmatter = false;
+        let name;
+        for (const line of lines) {
+            if (/^---[ \t]*$/.test(line)) {
+                if (inFrontmatter)
+                    return name;
+                inFrontmatter = true;
+                continue;
+            }
+            if (!inFrontmatter || !/^name:[ \t]*/.test(line))
+                continue;
+            name = line.replace(/^name:[ \t]*/, "").replace(/^["']|["']$/g, "");
+        }
+    }
+    catch { /* unreadable skill files are skipped by the shell catalog */ }
+    return undefined;
+}
+function skillFiles(root, companies) {
+    const files = [];
+    const appendDirectories = (base, skipHidden) => {
+        let names;
+        try {
+            names = fs.readdirSync(base).sort((a, b) => a.localeCompare(b, "en"));
+        }
+        catch {
+            return;
+        }
+        for (const name of names) {
+            if (name.startsWith(".") || (skipHidden && (name.startsWith("_") || name.startsWith("README"))))
+                continue;
+            const dir = path.join(base, name);
+            try {
+                if (!fs.statSync(dir).isDirectory())
+                    continue;
+                const file = path.join(dir, "SKILL.md");
+                if (fs.statSync(file).isFile())
+                    files.push(file);
+            }
+            catch { /* non-directories and missing/unreadable files are skipped */ }
+        }
+    };
+    for (const company of companies)
+        appendDirectories(path.join(root, "companies", company, "skills"), false);
+    appendDirectories(path.join(root, ".claude", "skills"), true);
+    let packages = [];
+    try {
+        packages = fs.readdirSync(path.join(root, "core", "packages")).sort((a, b) => a.localeCompare(b, "en"));
+    }
+    catch {
+        return files;
+    }
+    for (const pkg of packages)
+        appendDirectories(path.join(root, "core", "packages", pkg, "skills"), false);
+    return files;
+}
+export async function runSkillInstalled(args, root, env = process.env) {
+    const skill = args[0] ?? "";
+    let company = args[1] ?? env.HQ_ACTIVE_COMPANY ?? "";
+    if (!company) {
+        const [{ sessionCompanySlugs }, { fastFlagEnabledDefaultOn }, { MULTI_COMPANY_SESSION_LOCK_FLAG }] = await Promise.all([
+            import("../lib/core-utils/session-company.js"),
+            import("../native-fast-route.js"),
+            import("../lib/cli-flag-keys.js"),
+        ]);
+        const multiCompanyLockEnabled = await fastFlagEnabledDefaultOn(MULTI_COMPANY_SESSION_LOCK_FLAG, env);
+        company = sessionCompanySlugs(root, env, multiCompanyLockEnabled).join(",");
+    }
+    if (!/^[a-z0-9][a-z0-9_-]*$/.test(skill))
+        return { code: 1, stdout: "", stderr: "" };
+    if (!company)
+        company = "__hq_unbound_session__";
+    const companies = company.split(",");
+    if (companies.at(-1) === "")
+        companies.pop();
+    if (companies.some((slug) => !/^[a-z][a-z0-9_-]*$/.test(slug)))
+        return { code: 1, stdout: "", stderr: "" };
+    const resolver = path.join(root, "core", "scripts", "lib", "session-skill-catalog.sh");
+    try {
+        fs.accessSync(resolver, fs.constants.R_OK);
+    }
+    catch {
+        return failure(`skill availability resolver is missing: ${resolver}`, 2);
+    }
+    const seen = new Set();
+    for (const file of skillFiles(root, companies)) {
+        const name = skillName(file);
+        if (!name || seen.has(name))
+            continue;
+        seen.add(name);
+        if (name === skill) {
+            try {
+                if (fs.statSync(file).isFile())
+                    return { code: 0, stdout: "", stderr: "" };
+            }
+            catch { /* catalog entry disappeared, continue */ }
+        }
+    }
+    return { code: 1, stdout: "", stderr: "" };
+}
+//# sourceMappingURL=core-bucket-c-small-native.js.map

package/dist/commands/core-bucket-c-work-mesh-offer-native.d.ts

@@ -0,0 +1,7 @@
+export type WorkMeshOfferResult = {
+    code: number;
+    stdout: string;
+    stderr: string;
+};
+export declare function runWorkMeshProjectRegistrationOffer(args: readonly string[], root: string, env?: NodeJS.ProcessEnv): Promise<WorkMeshOfferResult>;
+//# sourceMappingURL=core-bucket-c-work-mesh-offer-native.d.ts.map