@indigoai-us/hq-cli 5.312.2-beta.0 → 5.314.0

package/dist/commands/core-worker-lint-native.js

@@ -1,160 +0,0 @@
-/** Native port of lint-shared-worker-skills.sh. */
-import * as crypto from "node:crypto";
-import * as path from "node:path";
-import { errorCode, missingOrUnreadable, resolveWorkerCallerRoot, } from "./core-worker-skills-runtime.js";
-export const WORKER_SKILL_LINT_ASSET = "core/scripts/lint-shared-worker-skills.sh";
-const DEFAULT_ROOTS = ["core/workers", "core/packages"];
-function joinFindPath(parent, child) {
-    return `${parent}${parent.endsWith("/") ? "" : "/"}${child}`;
-}
-function matchesFindPredicate(displayPath) {
-    // GNU/BSD find's `-path '*/skills/*.md'` glob lets `*` span `/`, but still
-    // requires a slash before `skills/`. In particular `skills/x.md` does not
-    // match while `./skills/x.md` and `workers/a/skills/x.md` do.
-    if (!/.+\/skills\/.*\.md$/.test(displayPath))
-        return false;
-    const name = displayPath.slice(displayPath.lastIndexOf("/") + 1);
-    if (name.startsWith("._"))
-        return false;
-    // Mirrors find's `-not -path '*/.*/*'`: a hidden directory is excluded only
-    // when it has a slash before and after the dot-prefixed component.
-    return !/\/\.[^/]*\//.test(displayPath);
-}
-function collectEntries(rootArg, cwd, fileSystem) {
-    const entries = [];
-    const visit = (displayPath) => {
-        const absolutePath = path.resolve(cwd, displayPath);
-        let info;
-        try {
-            info = fileSystem.lstatSync(absolutePath);
-        }
-        catch (error) {
-            if (missingOrUnreadable(error))
-                return;
-            throw error;
-        }
-        if (info.isDirectory()) {
-            let names;
-            try {
-                names = fileSystem.readdirSync(absolutePath);
-            }
-            catch (error) {
-                if (missingOrUnreadable(error))
-                    return;
-                throw error;
-            }
-            for (const name of names)
-                visit(joinFindPath(displayPath, name));
-            return;
-        }
-        if ((info.isFile() || info.isSymbolicLink()) && matchesFindPredicate(displayPath)) {
-            entries.push({ displayPath, absolutePath, symlink: info.isSymbolicLink() });
-        }
-    };
-    visit(rootArg);
-    return entries;
-}
-function ownershipDomain(displayPath) {
-    const value = displayPath.startsWith("./") ? displayPath.slice(2) : displayPath;
-    if (value.startsWith("core/packages/")) {
-        const rest = value.slice("core/packages/".length);
-        return `core/packages/${rest.split("/", 1)[0]}`;
-    }
-    if (value.startsWith("companies/")) {
-        const rest = value.slice("companies/".length);
-        return `companies/${rest.split("/", 1)[0]}`;
-    }
-    if (value === "core/workers" || value.startsWith("core/workers/"))
-        return "core/workers";
-    return value.split("/", 1)[0] ?? "";
-}
-function readFileForHash(filePath, fileSystem) {
-    const content = fileSystem.readFileSync(filePath);
-    return Buffer.isBuffer(content) ? content : Buffer.from(content);
-}
-function brokenLink(filePath, fileSystem) {
-    try {
-        fileSystem.statSync(filePath);
-        return false;
-    }
-    catch (error) {
-        if (missingOrUnreadable(error))
-            return true;
-        throw error;
-    }
-}
-function sorted(entries) {
-    // The legacy command pipes `find` into `sort`; the project environment uses
-    // the C locale, so preserve its byte ordering instead of ICU collation.
-    return entries.sort((left, right) => left.displayPath < right.displayPath ? -1 : left.displayPath > right.displayPath ? 1 : 0);
-}
-function resultError(error) {
-    const code = errorCode(error);
-    if (code === "EACCES" || code === "EPERM") {
-        return { code: 1, stdout: "", stderr: `md5sum: failed to read file: ${error instanceof Error ? error.message : String(error)}\n` };
-    }
-    throw error;
-}
-export function runWorkerSkillLint(args, dependencies) {
-    const { root, fs: fileSystem } = resolveWorkerCallerRoot(dependencies);
-    const roots = args.length > 0 ? args : DEFAULT_ROOTS;
-    const entries = sorted(roots.flatMap((entry) => collectEntries(entry, root, fileSystem)));
-    if (entries.length === 0) {
-        return {
-            code: 0,
-            stdout: `OK: worker-scoped skills are single-sourced (0 skill entries under: ${roots.join(" ")})\n`,
-            stderr: "",
-        };
-    }
-    const broken = [];
-    const hashGroups = new Map();
-    try {
-        for (const entry of entries) {
-            if (entry.symlink) {
-                if (brokenLink(entry.absolutePath, fileSystem))
-                    broken.push(entry.displayPath);
-                continue;
-            }
-            const digest = crypto.createHash("md5").update(readFileForHash(entry.absolutePath, fileSystem)).digest("hex");
-            const domain = ownershipDomain(entry.displayPath);
-            const key = `${domain}|${digest}`;
-            const group = hashGroups.get(key);
-            if (group)
-                group.paths.push(entry.displayPath);
-            else
-                hashGroups.set(key, { domain, paths: [entry.displayPath] });
-        }
-    }
-    catch (error) {
-        return resultError(error);
-    }
-    const duplicates = [...hashGroups.values()].filter((group) => group.paths.length >= 2);
-    const findings = duplicates.length + broken.length;
-    if (findings === 0) {
-        return {
-            code: 0,
-            stdout: `OK: worker-scoped skills are single-sourced (${entries.length} skill entries scanned under: ${roots.join(" ")})\n`,
-            stderr: "",
-        };
-    }
-    const lines = [];
-    if (duplicates.length > 0) {
-        lines.push("lint-shared-worker-skills: FAIL — duplicated worker skills (single-source these via _shared-skills/ + relative symlinks):");
-    }
-    for (const group of duplicates) {
-        lines.push(`  DUPLICATE in domain '${group.domain}' (identical content, ${group.paths.length} copies — pick one canonical and symlink the rest):`);
-        // The shell prefixes the newline-joined group only once, so only the first
-        // path carries these spaces in the resulting stderr.
-        lines.push(`    ${group.paths.join("\n")}`);
-    }
-    if (broken.length > 0) {
-        if (duplicates.length === 0)
-            lines.push("lint-shared-worker-skills: FAIL — broken shared-skill symlink(s):");
-        lines.push("  BROKEN (symlink target does not resolve):");
-        for (const filePath of broken)
-            lines.push(`    ${filePath}`);
-    }
-    lines.push("", "  Fix: keep ONE canonical file in the narrowest-scope _shared-skills/ store", "  (core/workers/_shared-skills, core/packages/<pack>/workers/_shared-skills,", "  or companies/<co>/workers/_shared-skills) and replace each duplicate with a", "  relative symlink. Helper: hq core worker share", "  Doc: core/knowledge/public/hq-core/shared-worker-skills.md");
-    return { code: 1, stdout: "", stderr: `${lines.join("\n")}\n` };
-}
-//# sourceMappingURL=core-worker-lint-native.js.map

package/dist/commands/core-worker-share-native.d.ts

@@ -1,5 +0,0 @@
-import { type WorkerSkillDependencies, type WorkerSkillResult } from "./core-worker-skills-runtime.js";
-export declare const WORKER_SKILL_SHARE_ASSET = "core/scripts/share-worker-skill.sh";
-export declare const WORKER_SKILL_SHARE_USAGE = "usage: $0 [--apply] [--force] <scope-dir> <skill-name> <worker-skill-path>...\n";
-export declare function runWorkerSkillShare(argv: string[], dependencies: WorkerSkillDependencies): WorkerSkillResult;
-//# sourceMappingURL=core-worker-share-native.d.ts.map

package/dist/commands/core-worker-share-native.js

@@ -1,260 +0,0 @@
-/** Native port of share-worker-skill.sh. */
-import * as path from "node:path";
-import { resolveBundledAsset } from "../utils/hq-roots.js";
-import { existsFollowingLinks, isDirectory, isSymlink, resolveWorkerCallerRoot, runGit, errorCode, } from "./core-worker-skills-runtime.js";
-export const WORKER_SKILL_SHARE_ASSET = "core/scripts/share-worker-skill.sh";
-export const WORKER_SKILL_SHARE_USAGE = "usage: $0 [--apply] [--force] <scope-dir> <skill-name> <worker-skill-path>...\n";
-function error(message, code = 2) {
-    return { code, stdout: "", stderr: `${message}\n` };
-}
-function toolFailure(output, tool, target, caught, destination) {
-    const code = errorCode(caught);
-    const reason = code === "EACCES" || code === "EPERM" ? "Permission denied"
-        : code === "ENOENT" ? "No such file or directory"
-            : code === "ENOTDIR" ? "Not a directory"
-                : code === "EEXIST" ? "File exists"
-                    : code === "ENOSPC" ? "No space left on device"
-                        : code === "EXDEV" ? "Invalid cross-device link"
-                            : caught instanceof Error ? caught.message : String(caught);
-    const message = tool === "mkdir" ? `mkdir: cannot create directory ‘${target}’: ${reason}`
-        : tool === "mv" ? `mv: cannot move '${target}' to '${destination ?? ""}': ${reason}`
-            : tool === "rm" ? `rm: cannot remove '${target}': ${reason}`
-                : `ln: failed to create symbolic link '${target}': ${reason}`;
-    return { code: 1, stdout: `${output.join("\n")}\n`, stderr: `${message}\n` };
-}
-function removeOneTrailingSlash(value) {
-    return value.endsWith("/") ? value.slice(0, -1) : value;
-}
-function stripOneDotSlash(value) {
-    return value.startsWith("./") ? value.slice(2) : value;
-}
-function isUnderScope(workerPath, scopeDir) {
-    const worker = stripOneDotSlash(workerPath);
-    const scope = stripOneDotSlash(scopeDir);
-    return worker.startsWith(`${scope}/`);
-}
-function relativePath(fromDirectory, toFile) {
-    const from = stripOneDotSlash(fromDirectory);
-    const to = stripOneDotSlash(toFile);
-    const fromParts = from.split("/");
-    const toParts = to.split("/");
-    let index = 0;
-    while (index < fromParts.length && index < toParts.length && fromParts[index] === toParts[index])
-        index += 1;
-    const up = "../".repeat(fromParts.length - index);
-    const down = toParts.slice(index).join("/");
-    return `${up}${down}`;
-}
-function isRegularFile(filePath, fileSystem) {
-    if (isSymlink(filePath, fileSystem))
-        return false;
-    try {
-        return fileSystem.statSync(filePath).isFile();
-    }
-    catch {
-        return false;
-    }
-}
-function readLink(filePath, fileSystem) {
-    return fileSystem.readlinkSync(filePath);
-}
-function sameBytes(leftPath, rightPath, fileSystem) {
-    try {
-        const left = fileSystem.readFileSync(leftPath);
-        const right = fileSystem.readFileSync(rightPath);
-        return Buffer.from(left).equals(Buffer.from(right));
-    }
-    catch {
-        // The shell sends cmp's diagnostics to /dev/null and treats every nonzero
-        // result as a drifted copy.
-        return false;
-    }
-}
-function unlinkIfPresent(filePath, fileSystem) {
-    try {
-        fileSystem.unlinkSync(filePath);
-    }
-    catch (caught) {
-        const code = caught && typeof caught === "object" && "code" in caught
-            ? caught.code
-            : undefined;
-        if (code !== "ENOENT")
-            throw caught;
-    }
-}
-function forceSymlink(target, filePath, fileSystem) {
-    unlinkIfPresent(filePath, fileSystem);
-    fileSystem.symlinkSync(target, filePath);
-}
-function runtimeScriptPath(dependencies) {
-    return dependencies.scriptPath ?? resolveBundledAsset(WORKER_SKILL_SHARE_ASSET);
-}
-export function runWorkerSkillShare(argv, dependencies) {
-    let apply = false;
-    let force = false;
-    const args = [];
-    for (const value of argv) {
-        if (value === "--apply")
-            apply = true;
-        else if (value === "--force")
-            force = true;
-        else if (value.startsWith("-"))
-            return error(`unknown flag: ${value}`);
-        else
-            args.push(value);
-    }
-    if (args.length < 3) {
-        return error(WORKER_SKILL_SHARE_USAGE.replace("$0", runtimeScriptPath(dependencies)).trimEnd());
-    }
-    const { root, env, fs: fileSystem } = resolveWorkerCallerRoot(dependencies);
-    const scopeDir = removeOneTrailingSlash(args[0]);
-    const skillName = args[1];
-    const workerPaths = args.slice(2);
-    if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(skillName)) {
-        return error(`error: skill-name '${skillName}' is not a bare skill name (no slashes, no .md)`);
-    }
-    if (scopeDir === "" || !isDirectory(path.resolve(root, scopeDir), fileSystem)) {
-        return error(`error: scope dir does not exist: ${scopeDir}`);
-    }
-    const canonical = `${scopeDir}/_shared-skills/${skillName}.md`;
-    const canonicalPath = path.resolve(root, canonical);
-    for (const originalPath of workerPaths) {
-        const workerPath = stripOneDotSlash(originalPath);
-        if (!isUnderScope(workerPath, scopeDir)) {
-            return error(`error: worker path '${workerPath}' is not under scope dir '${scopeDir}'\n       canonical must live in the narrowest scope covering all sharers;\n       cross-scope symlinks are disallowed. Aborting (no changes made).`);
-        }
-    }
-    const output = [`Canonical: ${canonical}`, `Scope:     ${scopeDir}`];
-    if (!apply)
-        output.push("(dry run — pass --apply to make changes)");
-    const note = (message) => { output.push(message); };
-    const would = (message) => {
-        note(apply ? `  did:   ${message}` : `  would: ${message}`);
-    };
-    const canonicalIsReusable = existsFollowingLinks(canonicalPath, fileSystem) && !isSymlink(canonicalPath, fileSystem);
-    if (canonicalIsReusable) {
-        note("canonical already exists (regular file) — reusing it");
-    }
-    else {
-        const seed = workerPaths.find((workerPath) => isRegularFile(path.resolve(root, stripOneDotSlash(workerPath)), fileSystem));
-        if (seed === undefined) {
-            return {
-                ...error("error: no canonical exists and no worker path is a regular file to seed it from"),
-                stdout: `${output.join("\n")}\n`,
-            };
-        }
-        would(`mkdir -p ${scopeDir}/_shared-skills`);
-        would(`git mv ${seed} ${canonical}  (promote first copy to canonical)`);
-        if (apply) {
-            try {
-                fileSystem.mkdirSync(path.resolve(root, `${scopeDir}/_shared-skills`), { recursive: true });
-            }
-            catch (caught) {
-                return toolFailure(output, "mkdir", `${scopeDir}/_shared-skills`, caught);
-            }
-            let moved;
-            try {
-                moved = runGit(["mv", seed, canonical], root, env, dependencies.runGit);
-            }
-            catch (caught) {
-                if (errorCode(caught) === undefined)
-                    throw caught;
-                moved = { code: 127, stdout: "" };
-            }
-            if (moved.code !== 0) {
-                try {
-                    fileSystem.renameSync(path.resolve(root, stripOneDotSlash(seed)), canonicalPath);
-                }
-                catch (caught) {
-                    return toolFailure(output, "mv", seed, caught, canonical);
-                }
-            }
-        }
-    }
-    for (const originalPath of workerPaths) {
-        const workerPath = stripOneDotSlash(originalPath);
-        const targetDir = path.posix.dirname(workerPath);
-        const relative = relativePath(targetDir, canonical);
-        const absoluteWorkerPath = path.resolve(root, workerPath);
-        if (isSymlink(absoluteWorkerPath, fileSystem)) {
-            const current = readLink(absoluteWorkerPath, fileSystem);
-            if (current === relative) {
-                note(`ok: ${workerPath} already links to canonical`);
-                continue;
-            }
-            would(`relink ${workerPath} -> ${relative} (was: ${current})`);
-            if (apply) {
-                try {
-                    forceSymlink(relative, absoluteWorkerPath, fileSystem);
-                }
-                catch (caught) {
-                    return toolFailure(output, "ln", workerPath, caught);
-                }
-            }
-            continue;
-        }
-        if (existsFollowingLinks(absoluteWorkerPath, fileSystem)) {
-            if (sameBytes(absoluteWorkerPath, canonicalPath, fileSystem)) {
-                would(`replace identical copy ${workerPath} with symlink -> ${relative}`);
-                if (apply) {
-                    try {
-                        unlinkIfPresent(absoluteWorkerPath, fileSystem);
-                    }
-                    catch (caught) {
-                        return toolFailure(output, "rm", workerPath, caught);
-                    }
-                    try {
-                        fileSystem.symlinkSync(relative, absoluteWorkerPath);
-                    }
-                    catch (caught) {
-                        return toolFailure(output, "ln", workerPath, caught);
-                    }
-                }
-            }
-            else if (force) {
-                would(`FORCE replace DRIFTED copy ${workerPath} with symlink -> ${relative} (content discarded)`);
-                if (apply) {
-                    try {
-                        unlinkIfPresent(absoluteWorkerPath, fileSystem);
-                    }
-                    catch (caught) {
-                        return toolFailure(output, "rm", workerPath, caught);
-                    }
-                    try {
-                        fileSystem.symlinkSync(relative, absoluteWorkerPath);
-                    }
-                    catch (caught) {
-                        return toolFailure(output, "ln", workerPath, caught);
-                    }
-                }
-            }
-            else {
-                return {
-                    code: 3,
-                    stdout: `${output.join("\n")}\n`,
-                    stderr: `  DRIFT: ${workerPath} differs from canonical — reconcile by hand, then re-run\n         (diff ${workerPath} ${canonical}), or pass --force to accept canonical.\n`,
-                };
-            }
-        }
-        else {
-            would(`create symlink ${workerPath} -> ${relative}`);
-            if (apply) {
-                try {
-                    fileSystem.mkdirSync(path.resolve(root, targetDir), { recursive: true });
-                }
-                catch (caught) {
-                    return toolFailure(output, "mkdir", targetDir, caught);
-                }
-                try {
-                    fileSystem.symlinkSync(relative, absoluteWorkerPath);
-                }
-                catch (caught) {
-                    return toolFailure(output, "ln", workerPath, caught);
-                }
-            }
-        }
-    }
-    output.push("done.");
-    return { code: 0, stdout: `${output.join("\n")}\n`, stderr: "" };
-}
-//# sourceMappingURL=core-worker-share-native.js.map

package/dist/commands/core-worker-skills-command.d.ts

@@ -1,8 +0,0 @@
-export type WorkerSkillCommandName = "lint" | "share";
-export type WorkerSkillCommandContext = {
-    cwd: string;
-    hqRoot?: string;
-};
-/** Keep the shell rollback route byte-transparent while the family flag is off. */
-export declare function runWorkerSkillCommand(name: WorkerSkillCommandName, args: string[], context: WorkerSkillCommandContext): Promise<number>;
-//# sourceMappingURL=core-worker-skills-command.d.ts.map

package/dist/commands/core-worker-skills-command.js

@@ -1,33 +0,0 @@
-import { runBundledScript } from "../utils/run-bundled-script.js";
-import { coreNativeWorkerSkillsEnabled } from "./core-native-worker-skills-flag.js";
-import { runWorkerSkillLint, WORKER_SKILL_LINT_ASSET } from "./core-worker-lint-native.js";
-import { runWorkerSkillShare, WORKER_SKILL_SHARE_ASSET } from "./core-worker-share-native.js";
-const assets = {
-    lint: WORKER_SKILL_LINT_ASSET,
-    share: WORKER_SKILL_SHARE_ASSET,
-};
-/** Keep the shell rollback route byte-transparent while the family flag is off. */
-export async function runWorkerSkillCommand(name, args, context) {
-    if (!(await coreNativeWorkerSkillsEnabled())) {
-        const result = runBundledScript({
-            asset: assets[name],
-            args,
-            cwd: context.cwd,
-            hqRoot: context.hqRoot,
-        });
-        if (result.code !== 0)
-            process.exit(result.code);
-        return result.code;
-    }
-    const result = name === "lint"
-        ? runWorkerSkillLint(args, { cwd: context.cwd })
-        : runWorkerSkillShare(args, { cwd: context.cwd });
-    if (result.stdout)
-        process.stdout.write(result.stdout);
-    if (result.stderr)
-        process.stderr.write(result.stderr);
-    if (result.code !== 0)
-        process.exit(result.code);
-    return result.code;
-}
-//# sourceMappingURL=core-worker-skills-command.js.map

package/dist/commands/core-worker-skills-runtime.d.ts

@@ -1,33 +0,0 @@
-import * as fs from "node:fs";
-export type WorkerSkillResult = {
-    code: number;
-    stdout: string;
-    stderr: string;
-};
-export type WorkerSkillFs = Pick<typeof fs, "lstatSync" | "statSync" | "readdirSync" | "readFileSync" | "readlinkSync" | "existsSync" | "mkdirSync" | "renameSync" | "unlinkSync" | "symlinkSync">;
-export type GitResult = {
-    code: number;
-    stdout: string;
-};
-export type GitRunner = (args: string[], cwd: string, env: NodeJS.ProcessEnv) => GitResult;
-export type WorkerSkillDependencies = {
-    cwd: string;
-    env?: NodeJS.ProcessEnv;
-    fs?: WorkerSkillFs;
-    runGit?: GitRunner;
-    /** The bundled shell's absolute $0, used for byte-identical usage text. */
-    scriptPath?: string;
-};
-export declare function runGit(args: string[], cwd: string, env: NodeJS.ProcessEnv, injected?: GitRunner): GitResult;
-/** Match `git rev-parse --show-toplevel || pwd` without consulting HQ_ROOT. */
-export declare function resolveWorkerCallerRoot(dependencies: WorkerSkillDependencies): {
-    root: string;
-    env: NodeJS.ProcessEnv;
-    fs: WorkerSkillFs;
-};
-export declare function errorCode(error: unknown): string | undefined;
-export declare function missingOrUnreadable(error: unknown): boolean;
-export declare function isDirectory(filePath: string, fileSystem: WorkerSkillFs): boolean;
-export declare function isSymlink(filePath: string, fileSystem: WorkerSkillFs): boolean;
-export declare function existsFollowingLinks(filePath: string, fileSystem: WorkerSkillFs): boolean;
-//# sourceMappingURL=core-worker-skills-runtime.d.ts.map

package/dist/commands/core-worker-skills-runtime.js

@@ -1,86 +0,0 @@
-import { spawnSync } from "node:child_process";
-import * as fs from "node:fs";
-const SYSTEM_FS = fs;
-function processGit(args, cwd, env) {
-    // Tests that set this marker must inject a runner. This guard catches an
-    // accidental escape from a synthetic fixture before any real executable can
-    // be reached through PATH.
-    if (env.HQ_CORE_STUBS === "1") {
-        throw new Error("real git execution is disabled while HQ_CORE_STUBS=1");
-    }
-    const result = spawnSync("git", args, { cwd, env, encoding: "utf8" });
-    return {
-        code: result.status ?? 127,
-        stdout: result.stdout ?? "",
-    };
-}
-export function runGit(args, cwd, env, injected) {
-    return (injected ?? processGit)(args, cwd, env);
-}
-function shellPwd(cwd, env, fileSystem) {
-    const logical = env.PWD;
-    if (!logical || !logical.startsWith("/"))
-        return cwd;
-    try {
-        const logicalStat = fileSystem.statSync(logical);
-        const cwdStat = fileSystem.statSync(cwd);
-        if (logicalStat.dev === cwdStat.dev && logicalStat.ino === cwdStat.ino)
-            return logical;
-    }
-    catch {
-        // Bash falls back to its physical cwd when PWD no longer names this inode.
-    }
-    return cwd;
-}
-/** Match `git rev-parse --show-toplevel || pwd` without consulting HQ_ROOT. */
-export function resolveWorkerCallerRoot(dependencies) {
-    const env = dependencies.env ?? process.env;
-    const fileSystem = dependencies.fs ?? SYSTEM_FS;
-    const git = runGit(["rev-parse", "--show-toplevel"], dependencies.cwd, env, dependencies.runGit);
-    if (git.code === 0) {
-        // Command substitution removes every trailing LF and no other whitespace.
-        return { root: git.stdout.replace(/\n+$/, ""), env, fs: fileSystem };
-    }
-    return { root: shellPwd(dependencies.cwd, env, fileSystem), env, fs: fileSystem };
-}
-export function errorCode(error) {
-    if (!error || typeof error !== "object" || !("code" in error))
-        return undefined;
-    const code = error.code;
-    return typeof code === "string" ? code : undefined;
-}
-export function missingOrUnreadable(error) {
-    return ["ENOENT", "ENOTDIR", "EACCES", "EPERM", "ELOOP"].includes(errorCode(error) ?? "");
-}
-export function isDirectory(filePath, fileSystem) {
-    try {
-        return fileSystem.statSync(filePath).isDirectory();
-    }
-    catch (error) {
-        if (missingOrUnreadable(error))
-            return false;
-        throw error;
-    }
-}
-export function isSymlink(filePath, fileSystem) {
-    try {
-        return fileSystem.lstatSync(filePath).isSymbolicLink();
-    }
-    catch (error) {
-        if (missingOrUnreadable(error))
-            return false;
-        throw error;
-    }
-}
-export function existsFollowingLinks(filePath, fileSystem) {
-    try {
-        fileSystem.statSync(filePath);
-        return true;
-    }
-    catch (error) {
-        if (missingOrUnreadable(error))
-            return false;
-        throw error;
-    }
-}
-//# sourceMappingURL=core-worker-skills-runtime.js.map

package/dist/commands/daemon.d.ts

@@ -1,63 +0,0 @@
-/**
- * `hq daemon` — one supervisor for every HQ background service on a machine.
- *
- *   hq daemon                     status (same as `hq daemon status`)
- *   hq daemon install             detect the machine type, install the one OS unit
- *   hq daemon run                 what the OS unit runs; starts the default services
- *   hq daemon status [--json]
- *   hq daemon logs [unit] [--follow] [--lines N]
- *   hq daemon restart [unit] | trigger <unit>
- *   hq daemon enable|disable <service...>   per-machine overrides
- *   hq daemon migrate             list the older units it would take over (read-only)
- *   hq daemon uninstall [--purge]
- *
- * Hidden from `hq --help` while it rolls out.
- */
-import type { Command } from "commander";
-import { type LegacyUnit } from "../lib/daemon/legacy.js";
-import type { HostApp } from "../lib/daemon/supervisor.js";
-import { type SyncModeVaultClient } from "./sync-mode.js";
-import type { RunCommand } from "../lib/service-manager/launchd.js";
-export interface DaemonCommandDeps {
-    env: NodeJS.ProcessEnv;
-    home: string;
-    platform: NodeJS.Platform;
-    out: (line: string) => void;
-    err: (line: string) => void;
-    run: RunCommand;
-    nodeBinary: string;
-    hqBinary: string;
-    uid: number;
-    isRoot: boolean;
-    fileExists: (p: string) => boolean;
-    readFile: (p: string) => string;
-    /** Writes a root-owned file such as /etc/hq/machine-type, creating its folder. */
-    writeFile: (p: string, text: string) => void;
-    /** Older units in `home` (default: this user's home). */
-    legacyUnits: (home?: string) => LegacyUnit[];
-    resolveHqRoot: (flag: string | undefined) => string | undefined;
-    /** Home folder of the login user a box's system unit runs as. */
-    userHome: (user: string) => string;
-    /** The pid is a live `hq daemon run`. */
-    daemonAlive: (pid: number) => boolean;
-    /** Test seam for the company sync-mode commands. */
-    syncModeClient?: () => Promise<SyncModeVaultClient>;
-    windowsUser?: string;
-    windowsHeadlessLauncher?: string;
-    systemUnitDir?: string;
-    systemRecordPath?: string;
-}
-/**
- * The HQ folder install records: --hq-root, else the CLI's shared resolution
- * (HQ_ROOT, the tree around the current folder, the folder the installer or
- * menubar recorded, the well-known locations). Undefined when none resolves.
- */
-/** Validate `hq daemon run --host`; the desktop app is the only host. */
-export declare function parseDaemonHost(value: string | undefined): HostApp | undefined;
-export declare function resolveDaemonHqRoot(flag: string | undefined, where: {
-    env: NodeJS.ProcessEnv;
-    cwd: string;
-    home: string;
-}): string | undefined;
-export declare function registerDaemonCommand(program: Command, over?: Partial<DaemonCommandDeps>): Command;
-//# sourceMappingURL=daemon.d.ts.map