@catalyst-cloud/cli 0.8.0

package/vendor/paths/legacy-installer.js

@@ -0,0 +1,154 @@
+/**
+ * The ten roles, in CTC-2548's own order. `artifacts` is last-but-one and is the one role with
+ * `base: "none"` — it is minted per run by the caller (`CATALYST_ARTIFACT_DIR`) and this script
+ * must never invent a default for it.
+ */
+export const CATALYST_DIRECTORY_ROLES = [
+    {
+        role: "repoRoot",
+        variable: "CATALYST_REPO_ROOT",
+        base: "catalyst-home",
+        segments: ["repos"],
+        creatable: true,
+        mode: "0755",
+    },
+    {
+        role: "worktrees",
+        variable: "CATALYST_WORKTREES_DIR",
+        base: "catalyst-home",
+        segments: ["wt"],
+        creatable: true,
+        mode: "0755",
+    },
+    {
+        role: "logs",
+        variable: "CATALYST_LOGS_DIR",
+        base: "xdg-state",
+        segments: ["catalyst", "logs"],
+        creatable: true,
+        mode: "0755",
+    },
+    {
+        role: "events",
+        variable: "CATALYST_EVENTS_DIR",
+        base: "xdg-state",
+        segments: ["catalyst", "events"],
+        creatable: true,
+        mode: "0755",
+    },
+    {
+        role: "replica",
+        variable: "CATALYST_REPLICA_DIR",
+        base: "xdg-state",
+        segments: ["catalyst", "replica"],
+        creatable: true,
+        mode: "0700",
+    },
+    {
+        role: "config",
+        variable: "CATALYST_CONFIG_DIR",
+        base: "xdg-config",
+        segments: ["catalyst"],
+        creatable: true,
+        mode: "0700",
+    },
+    {
+        role: "cache",
+        variable: "CATALYST_CACHE_DIR",
+        base: "xdg-cache",
+        segments: ["catalyst"],
+        creatable: true,
+        mode: "0755",
+    },
+    {
+        role: "state",
+        variable: "CATALYST_STATE_DIR",
+        base: "xdg-state",
+        segments: ["catalyst"],
+        creatable: true,
+        mode: "0755",
+    },
+    {
+        role: "artifacts",
+        variable: "CATALYST_ARTIFACT_DIR",
+        base: "none",
+        segments: [],
+        creatable: false,
+        mode: "0700",
+    },
+    {
+        role: "skills",
+        variable: "CATALYST_SKILLS_HOME",
+        base: "xdg-data",
+        segments: ["catalyst"],
+        creatable: true,
+        mode: "0755",
+    },
+];
+/** The roles setup actually creates, in table order. Never hand-counted (CTC-2552 was exactly that bug). */
+export const CREATABLE_DIRECTORY_ROLES = CATALYST_DIRECTORY_ROLES.filter((r) => r.creatable);
+/** The shell (and TypeScript) expression for a base's default, before segments are appended. */
+function baseDefault(base, env) {
+    switch (base) {
+        case "catalyst-home":
+            if (env.CATALYST_HOME)
+                return env.CATALYST_HOME;
+            return env.HOME ? `${env.HOME}/catalyst` : undefined;
+        case "xdg-state":
+            if (env.XDG_STATE_HOME)
+                return env.XDG_STATE_HOME;
+            return env.HOME ? `${env.HOME}/.local/state` : undefined;
+        case "xdg-config":
+            if (env.XDG_CONFIG_HOME)
+                return env.XDG_CONFIG_HOME;
+            return env.HOME ? `${env.HOME}/.config` : undefined;
+        case "xdg-cache":
+            if (env.XDG_CACHE_HOME)
+                return env.XDG_CACHE_HOME;
+            return env.HOME ? `${env.HOME}/.cache` : undefined;
+        case "xdg-data":
+            if (env.XDG_DATA_HOME)
+                return env.XDG_DATA_HOME;
+            return env.HOME ? `${env.HOME}/.local/share` : undefined;
+        case "none":
+            return undefined;
+    }
+}
+/** The shell expression for a base's default (mirrors {@link baseDefault}, rendered instead of resolved). */
+export const LEGACY_BASE_SHELL = {
+    "catalyst-home": "${CATALYST_HOME:-$HOME/catalyst}",
+    "xdg-state": "${XDG_STATE_HOME:-$HOME/.local/state}",
+    "xdg-config": "${XDG_CONFIG_HOME:-$HOME/.config}",
+    "xdg-cache": "${XDG_CACHE_HOME:-$HOME/.cache}",
+    "xdg-data": "${XDG_DATA_HOME:-$HOME/.local/share}",
+    none: null,
+};
+function findRole(role) {
+    const found = CATALYST_DIRECTORY_ROLES.find((r) => r.role === role);
+    if (!found)
+        throw new Error(`catalyst-directories: unknown role "${role}"`);
+    return found;
+}
+/**
+ * Resolve one role's directory from `env`, the same precedence a shell caller gets from the
+ * rendered block: explicit variable → base default → a NAMED refusal, never a relative guess
+ * (the house shape: apps/host-sync/src/cli.ts:801-812).
+ */
+export function resolveWorkstationDir(role, env) {
+    const def = findRole(role);
+    const explicit = env[def.variable];
+    if (explicit)
+        return explicit;
+    if (def.base === "none") {
+        return {
+            refused: `${def.variable} is not set — this directory is minted per run, it has no default`,
+        };
+    }
+    const base = baseDefault(def.base, env);
+    if (base === undefined) {
+        return {
+            refused: `HOME is not set and ${def.variable} is not set — cannot resolve a default for "${role}"`,
+        };
+    }
+    return def.segments.length > 0 ? `${base}/${def.segments.join("/")}` : base;
+}

package/vendor/paths/node.d.ts

@@ -0,0 +1,18 @@
+import { type Environment, type MachinePaths, type MachineRole, type Profile } from "./index.js";
+export interface MachineFileOptions {
+    readonly env: Environment;
+    readonly profile?: Profile;
+    readonly file?: string;
+}
+export declare function machinePathsFile(options: MachineFileOptions): string | undefined;
+export declare function loadMachinePaths(options: MachineFileOptions): Promise<MachinePaths | undefined>;
+/** Atomic replacement. Existing parent permissions are never modified. */
+export declare function writeMachinePaths(file: string, record: MachinePaths): Promise<void>;
+export interface LegacyDiscoveryOptions {
+    readonly env: Environment;
+    readonly replicaDb?: string;
+    /** Known file candidates supplied by setup; directories and empty files are never adopted. */
+    readonly replicaCandidates?: readonly string[];
+}
+/** Discover legacy CLI locations using metadata only; never touch DB/cursor/lock contents. */
+export declare function discoverLegacyPaths(options: LegacyDiscoveryOptions): Promise<Partial<Record<MachineRole, string>>>;

package/vendor/paths/node.js

@@ -0,0 +1,102 @@
+/** Node-only machine-file adapter. No replica database is opened or moved here. */
+import fs from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { dirname, join } from "node:path";
+import { absolutePath, parseMachinePaths, } from "./index.js";
+export function machinePathsFile(options) {
+    const explicit = options.file ?? options.env.CATALYST_PATHS_FILE;
+    if (explicit !== undefined)
+        return absolutePath(explicit, "CATALYST_PATHS_FILE");
+    if (options.profile === "container")
+        return undefined;
+    const config = options.env.XDG_CONFIG_HOME ?? `${absolutePath(options.env.HOME, "HOME")}/.config`;
+    return join(absolutePath(config, "XDG_CONFIG_HOME"), "catalyst/paths.json");
+}
+function hasCode(error, code) {
+    return error instanceof Error && "code" in error && error.code === code;
+}
+async function present(path) {
+    try {
+        await fs.lstat(path);
+        return true;
+    }
+    catch (error) {
+        if (hasCode(error, "ENOENT"))
+            return false;
+        throw error;
+    }
+}
+export async function loadMachinePaths(options) {
+    const file = machinePathsFile(options);
+    if (file === undefined)
+        return undefined;
+    try {
+        // Only an absent implicit file is unconfigured. Broken links and explicit missing files fail.
+        if (options.file === undefined &&
+            options.env.CATALYST_PATHS_FILE === undefined &&
+            !(await present(file)))
+            return undefined;
+        return parseMachinePaths(JSON.parse(await fs.readFile(file, "utf8")));
+    }
+    catch (cause) {
+        throw new Error(`paths: cannot read machine file ${file}: ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
+    }
+}
+/** Atomic replacement. Existing parent permissions are never modified. */
+export async function writeMachinePaths(file, record) {
+    absolutePath(file, "CATALYST_PATHS_FILE");
+    const content = `${JSON.stringify(parseMachinePaths(record), null, 2)}\n`;
+    await fs.mkdir(dirname(file), { recursive: true, mode: 0o700 });
+    const temporary = `${file}.${randomUUID()}.tmp`;
+    const handle = await fs.open(temporary, "wx", 0o600);
+    try {
+        await handle.writeFile(content, "utf8");
+        await handle.sync();
+        await handle.close();
+        await fs.rename(temporary, file);
+    }
+    finally {
+        await handle.close();
+        await fs.rm(temporary, { force: true });
+    }
+}
+/** Discover legacy CLI locations using metadata only; never touch DB/cursor/lock contents. */
+export async function discoverLegacyPaths(options) {
+    const config = absolutePath(options.env.CATALYST_CONFIG_DIR ??
+        join(absolutePath(options.env.CATALYST_SKILLS_HOME ?? options.env.HOME, "HOME or deprecated CATALYST_SKILLS_HOME"), ".config/catalyst-cloud"), "CATALYST_CONFIG_DIR");
+    const customerFile = join(config, "customer.json");
+    const found = {};
+    if (await present(config)) {
+        if (!(await fs.stat(config)).isDirectory())
+            throw new Error(`paths: legacy config is not a directory: ${config}`);
+        found.config = config;
+    }
+    let configured;
+    if (await present(customerFile)) {
+        const customer = JSON.parse(await fs.readFile(customerFile, "utf8"));
+        if (typeof customer !== "object" || customer === null || Array.isArray(customer))
+            throw new Error(`paths: invalid legacy config ${customerFile}`);
+        if ("replicaDb" in customer && customer.replicaDb !== undefined)
+            configured = absolutePath(customer.replicaDb, "legacy replicaDb");
+        found.config = config;
+    }
+    const explicit = options.replicaDb ?? options.env.CATALYST_REPLICA_DB ?? configured;
+    if (explicit !== undefined) {
+        found.replicaDb = absolutePath(explicit, "CATALYST_REPLICA_DB");
+        return found;
+    }
+    const fallback = join(config, "replica.db");
+    const populated = [];
+    for (const candidate of new Set([fallback, ...(options.replicaCandidates ?? [])])) {
+        absolutePath(candidate, "replica candidate");
+        if (!(await present(candidate)))
+            continue;
+        const stat = await fs.stat(candidate);
+        if (stat.isFile() && stat.size > 0)
+            populated.push(candidate);
+    }
+    if (populated.length > 1)
+        throw new Error(`paths: ambiguous populated replicas: ${populated.join(", ")}; set CATALYST_REPLICA_DB explicitly`);
+    found.replicaDb = populated[0] ?? fallback;
+    return found;
+}

package/vendor/paths/provenance.json

@@ -0,0 +1,17 @@
+{
+  "repository": "coalesce-labs/catalyst-cloud",
+  "commit": "c391358d06720985126c15b7fa9d9d6ad1878211",
+  "sourceSha256": {
+    "index.ts": "f44b08a7de1c72d20b77f0c79a1b54b9485c6b0e76eecca298c78f170d7773cd",
+    "node.ts": "eb8ad2be272c1d9cf8f2b754e10c89bee237260f8ed0769e612e17a6a94517c5",
+    "legacy-installer.ts": "7da0a9c78d44b48e69a0e0ed9c2059d79391b2a519549fff824aaa8130924c2e"
+  },
+  "runtimeSha256": {
+    "index.d.ts": "02fdf46bf7bf39acf01fde211655d0c60e5cc529ec7964bbb9a8876270fc8f19",
+    "index.js": "9ed35d5cfd765383584047ed408746e0154209a627861d252729dce741ef0830",
+    "legacy-installer.d.ts": "e712488bc7e7aac77e47bbf89e31b6bdcdda9a61c7e81b8a424eb234ac0bb7c3",
+    "legacy-installer.js": "78e198e4d6b8b8c8998b18b10d52481b1b5507f8e0f3de6d1049f9b0f9a4b6d9",
+    "node.d.ts": "c931a7b077f5b87ed6f4520debf8d584dae7cfb7f15ee9a38db9100870ef5c4b",
+    "node.js": "f68dfba24f86b492249f2cfce4a45e72091338be32046c9d8abd246a3c916f98"
+  }
+}