@instafy/cli 0.1.8 → 0.1.9

package/dist/git-wrapper.js

@@ -0,0 +1,502 @@
+import { spawnSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import kleur from "kleur";
+const INSTAFY_GIT_HELPER_VALUE = "!instafy git credential";
+function pathExists(candidate) {
+    try {
+        fs.statSync(candidate);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function findInstafyGitContext(startDir) {
+    let current = path.resolve(startDir);
+    const root = path.parse(current).root;
+    while (true) {
+        const gitDir = path.join(current, ".instafy", ".git");
+        if (pathExists(gitDir)) {
+            return { workTree: current, gitDir };
+        }
+        if (current === root)
+            break;
+        current = path.dirname(current);
+    }
+    return null;
+}
+function splitGitCommand(userArgs) {
+    const globalArgs = [];
+    let index = 0;
+    while (index < userArgs.length) {
+        const arg = userArgs[index] ?? "";
+        if (arg === "--") {
+            index += 1;
+            break;
+        }
+        if (!arg.startsWith("-") || arg === "-") {
+            break;
+        }
+        globalArgs.push(arg);
+        // Skip values for global options that consume the next token.
+        if (arg === "-c" || arg === "--config-env" || arg === "--exec-path" || arg === "--namespace") {
+            if (index + 1 < userArgs.length) {
+                globalArgs.push(userArgs[index + 1] ?? "");
+                index += 2;
+                continue;
+            }
+        }
+        index += 1;
+    }
+    const command = index < userArgs.length ? (userArgs[index] ?? null) : null;
+    const commandArgs = command ? userArgs.slice(index + 1) : [];
+    return { globalArgs, command, commandArgs };
+}
+function validateGitArgs(userArgs) {
+    let parsingGlobalOptions = true;
+    for (let index = 0; index < userArgs.length; index += 1) {
+        const arg = userArgs[index] ?? "";
+        if (!parsingGlobalOptions) {
+            continue;
+        }
+        if (arg === "--") {
+            parsingGlobalOptions = false;
+            continue;
+        }
+        if (!arg.startsWith("-") || arg === "-") {
+            parsingGlobalOptions = false;
+            continue;
+        }
+        if (arg === "--git-dir" || arg.startsWith("--git-dir=") || arg === "--work-tree" || arg.startsWith("--work-tree=") || arg === "-C") {
+            throw new Error(`Unsupported argument "${arg}". Use ${kleur.cyan("cd")} instead; ${kleur.cyan("instafy git")} manages --git-dir/--work-tree automatically.`);
+        }
+        // Skip the value for global options that consume the next token.
+        if (arg === "-c" || arg === "--config-env" || arg === "--exec-path" || arg === "--namespace") {
+            index += 1;
+        }
+    }
+}
+export function buildInstafyGitArgs(context, userArgs) {
+    validateGitArgs(userArgs);
+    return ["--git-dir", context.gitDir, "--work-tree", context.workTree, ...userArgs];
+}
+function normalizePathSpec(raw) {
+    return (raw ?? "").replace(/\\/g, "/").trim().replace(/^\/+/, "");
+}
+function isReservedSyncPath(pathSpec) {
+    const normalized = normalizePathSpec(pathSpec);
+    if (!normalized) {
+        return false;
+    }
+    if (normalized === ".instafy" || normalized.startsWith(".instafy/")) {
+        return true;
+    }
+    if (normalized === ".instafy/origin-staging" || normalized.startsWith(".instafy/origin-staging/")) {
+        return true;
+    }
+    return normalized.split("/").some((segment) => segment === ".git" || segment.startsWith(".git.instafy-hidden-"));
+}
+function gitCapture(context, args, options) {
+    const result = spawnSync("git", ["--git-dir", context.gitDir, "--work-tree", context.workTree, ...args], {
+        cwd: options.cwd,
+        encoding: "utf8",
+        env: { ...process.env, GIT_TERMINAL_PROMPT: "0" },
+    });
+    return {
+        status: typeof result.status === "number" ? result.status : 1,
+        stdout: typeof result.stdout === "string" ? result.stdout : "",
+        stderr: typeof result.stderr === "string" ? result.stderr : "",
+        error: result.error,
+    };
+}
+function collectDirtyPaths(context, options) {
+    const result = gitCapture(context, ["status", "--porcelain=v1"], options);
+    if (result.error) {
+        throw new Error(`Failed to run git status: ${result.error.message}`);
+    }
+    if (result.status !== 0) {
+        throw new Error(`git status failed (${result.status}): ${result.stderr.trim()}`);
+    }
+    const paths = [];
+    for (const line of result.stdout.split(/\r?\n/)) {
+        if (!line.trim())
+            continue;
+        if (line.length < 4)
+            continue;
+        const raw = line.slice(3).trim();
+        if (!raw)
+            continue;
+        const rename = raw.split(" -> ");
+        if (rename.length === 2) {
+            for (const entry of rename) {
+                const normalized = normalizePathSpec(entry).replace(/\/+$/, "");
+                if (normalized)
+                    paths.push(normalized);
+            }
+            continue;
+        }
+        const normalized = normalizePathSpec(raw).replace(/\/+$/, "");
+        if (normalized)
+            paths.push(normalized);
+    }
+    paths.sort((a, b) => a.localeCompare(b));
+    const unique = [];
+    for (const value of paths) {
+        if (unique.length === 0 || unique[unique.length - 1] !== value) {
+            unique.push(value);
+        }
+    }
+    return unique;
+}
+function findEmbeddedGitDirs(context, pathSpecs) {
+    const instafyGitDir = path.resolve(context.gitDir);
+    const seen = new Set();
+    for (const rawPath of pathSpecs) {
+        const normalized = normalizePathSpec(rawPath).replace(/\/+$/, "");
+        if (!normalized || normalized === "." || normalized === "/") {
+            continue;
+        }
+        let cursor = normalized;
+        while (cursor && cursor !== ".") {
+            const candidate = path.join(context.workTree, ...cursor.split("/"), ".git");
+            if (pathExists(candidate) && path.resolve(candidate) !== instafyGitDir) {
+                seen.add(path.resolve(candidate));
+            }
+            const next = path.posix.dirname(cursor);
+            if (next === "." || next === cursor) {
+                break;
+            }
+            cursor = next;
+        }
+    }
+    const candidates = Array.from(seen);
+    candidates.sort((a, b) => {
+        const depthA = a.split(path.sep).length;
+        const depthB = b.split(path.sep).length;
+        return depthB - depthA;
+    });
+    return candidates;
+}
+function hideEmbeddedGitDirs(context, pathSpecs) {
+    const candidates = findEmbeddedGitDirs(context, pathSpecs);
+    if (candidates.length === 0) {
+        return [];
+    }
+    const stagingBase = path.join(context.workTree, ".instafy", "origin-staging", "embedded-git");
+    fs.mkdirSync(stagingBase, { recursive: true });
+    const renames = [];
+    for (const candidate of candidates) {
+        let hidden = path.join(stagingBase, randomUUID());
+        for (let attempt = 0; attempt < 8; attempt += 1) {
+            if (!pathExists(hidden))
+                break;
+            hidden = path.join(stagingBase, randomUUID());
+        }
+        fs.renameSync(candidate, hidden);
+        renames.push({ original: candidate, hidden });
+    }
+    return renames;
+}
+function restoreEmbeddedGitDirs(renames) {
+    for (let index = renames.length - 1; index >= 0; index -= 1) {
+        const rename = renames[index];
+        if (!rename)
+            continue;
+        try {
+            fs.renameSync(rename.hidden, rename.original);
+        }
+        catch {
+            // ignore restore failures; leave evidence in .instafy/origin-staging for debugging
+        }
+    }
+}
+function parseAddArgs(commandArgs) {
+    const addOptions = [];
+    const pathSpecs = [];
+    let inPaths = false;
+    for (const arg of commandArgs) {
+        if (inPaths) {
+            pathSpecs.push(arg);
+            continue;
+        }
+        if (arg === "--") {
+            inPaths = true;
+            continue;
+        }
+        if (arg.startsWith("-") && arg !== "-") {
+            addOptions.push(arg);
+            continue;
+        }
+        inPaths = true;
+        pathSpecs.push(arg);
+    }
+    return { addOptions, pathSpecs };
+}
+function runInstafyGitAdd(context, globalArgs, commandArgs, options) {
+    const parsed = parseAddArgs(commandArgs);
+    const normalizedPathSpecs = parsed.pathSpecs
+        .map((spec) => normalizePathSpec(spec))
+        .filter((spec) => spec && spec !== "." && spec !== "/");
+    const stageAll = normalizedPathSpecs.length === 0;
+    const stagePaths = stageAll
+        ? collectDirtyPaths(context, options).filter((entry) => !isReservedSyncPath(entry))
+        : normalizedPathSpecs.filter((entry) => !isReservedSyncPath(entry));
+    if (stagePaths.length === 0) {
+        return 0;
+    }
+    const addOptions = [...parsed.addOptions];
+    if (stageAll && !addOptions.some((opt) => opt === "-A" || opt === "--all")) {
+        addOptions.unshift("-A");
+    }
+    const renames = hideEmbeddedGitDirs(context, stagePaths);
+    try {
+        const result = spawnSync("git", [
+            "--git-dir",
+            context.gitDir,
+            "--work-tree",
+            context.workTree,
+            ...globalArgs,
+            "add",
+            ...addOptions,
+            "--",
+            ...stagePaths,
+        ], { stdio: "inherit", cwd: options.cwd, env: { ...process.env, GIT_TERMINAL_PROMPT: "0" } });
+        if (result.error) {
+            throw new Error(`Failed to run git add: ${result.error.message}`);
+        }
+        return typeof result.status === "number" ? result.status : 1;
+    }
+    finally {
+        restoreEmbeddedGitDirs(renames);
+    }
+}
+export function runInstafyGit(userArgs, options) {
+    const cwd = options?.cwd ?? process.cwd();
+    if (userArgs.length === 0 || userArgs[0] === "--help" || userArgs[0] === "-h") {
+        // Keep this minimal so it doesn't diverge from Git help output.
+        console.log("instafy git <git-args...>");
+        console.log("");
+        console.log(`Runs ${kleur.cyan("git")} against the Instafy canonical repo at ${kleur.cyan(".instafy/.git")} (auto-detected by walking up from cwd).`);
+        console.log("");
+        console.log("Example:");
+        console.log(`  ${kleur.cyan('instafy git status')}`);
+        console.log(`  ${kleur.cyan('instafy git add -A')}`);
+        console.log(`  ${kleur.cyan('instafy git commit -am "instafy: checkpoint"')}`);
+        return 0;
+    }
+    const context = findInstafyGitContext(cwd);
+    if (!context) {
+        throw new Error([
+            "No Instafy canonical git checkout found (expected .instafy/.git).",
+            "",
+            "Tips:",
+            `- Run this inside a git-canonical workspace (where ${kleur.cyan(".instafy/.git")} exists).`,
+            `- If you're trying to operate on a user repo, use normal ${kleur.cyan("git")} (it uses .git).`,
+        ].join("\n"));
+    }
+    validateGitArgs(userArgs);
+    const split = splitGitCommand(userArgs);
+    if (split.command === "add") {
+        return runInstafyGitAdd(context, split.globalArgs, split.commandArgs, { cwd });
+    }
+    const args = buildInstafyGitArgs(context, ["-c", `credential.helper=${INSTAFY_GIT_HELPER_VALUE}`, ...userArgs]);
+    const result = spawnSync("git", args, {
+        stdio: "inherit",
+        cwd,
+        env: { ...process.env, GIT_TERMINAL_PROMPT: "0" },
+    });
+    if (result.error) {
+        throw new Error(`Failed to run git: ${result.error.message}`);
+    }
+    return typeof result.status === "number" ? result.status : 1;
+}
+function printGitSyncHelp() {
+    console.log("instafy git sync [options]");
+    console.log("");
+    console.log("Calls the Origin git sync endpoint (POST /git/sync) for the current runtime/workspace.");
+    console.log("");
+    console.log("Options:");
+    console.log("  -m, --message <msg>       Commit message (recommended)");
+    console.log("  --path <relativePath>     Only sync selected path(s) (repeatable)");
+    console.log("  --origin-endpoint <url>   Override Origin base URL (default: $ORIGIN_ENDPOINT or localhost)");
+    console.log("  --origin-token <token>    Override Origin bearer token (default: $ORIGIN_INTERNAL_TOKEN)");
+    console.log("  --json                    Output JSON");
+    console.log("");
+    console.log("Env fallback:");
+    console.log("  ORIGIN_ENDPOINT, ORIGIN_BIND_PORT, ORIGIN_INTERNAL_TOKEN, RUNTIME_ACCESS_TOKEN");
+}
+function normalizeToken(raw) {
+    if (typeof raw !== "string")
+        return null;
+    const trimmed = raw.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function normalizeUrl(raw) {
+    return raw.trim().replace(/\/+$/, "");
+}
+function resolveOriginEndpoint(override) {
+    const direct = normalizeToken(override) ?? normalizeToken(process.env["ORIGIN_ENDPOINT"]);
+    if (direct) {
+        return normalizeUrl(direct);
+    }
+    const portRaw = normalizeToken(process.env["ORIGIN_BIND_PORT"]);
+    const port = portRaw ? Number.parseInt(portRaw, 10) : 54332;
+    const resolvedPort = Number.isFinite(port) && port > 0 ? port : 54332;
+    return `http://127.0.0.1:${resolvedPort}`;
+}
+function resolveOriginToken(override) {
+    const token = normalizeToken(override) ??
+        normalizeToken(process.env["ORIGIN_INTERNAL_TOKEN"]) ??
+        normalizeToken(process.env["RUNTIME_ACCESS_TOKEN"]);
+    if (!token) {
+        throw new Error([
+            "Origin bearer token missing.",
+            "",
+            "Provide one of:",
+            "- --origin-token <token>",
+            "- ORIGIN_INTERNAL_TOKEN=<token> (recommended inside runtimes)",
+            "- RUNTIME_ACCESS_TOKEN=<token>",
+        ].join("\n"));
+    }
+    return token;
+}
+function parseGitSyncArgs(args) {
+    let message = null;
+    let json = false;
+    let originEndpointOverride = null;
+    let originTokenOverride = null;
+    const paths = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index] ?? "";
+        if (arg === "--help" || arg === "-h") {
+            return "help";
+        }
+        if (arg === "--json") {
+            json = true;
+            continue;
+        }
+        if (arg === "-m" || arg === "--message") {
+            const value = args[index + 1];
+            if (typeof value !== "string" || value.trim().length === 0) {
+                throw new Error(`${arg} requires a non-empty value`);
+            }
+            message = value.trim();
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith("--message=")) {
+            const value = arg.slice("--message=".length).trim();
+            if (!value) {
+                throw new Error("--message requires a non-empty value");
+            }
+            message = value;
+            continue;
+        }
+        if (arg === "--origin-endpoint") {
+            const value = args[index + 1];
+            if (typeof value !== "string" || value.trim().length === 0) {
+                throw new Error("--origin-endpoint requires a URL");
+            }
+            originEndpointOverride = value.trim();
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith("--origin-endpoint=")) {
+            const value = arg.slice("--origin-endpoint=".length).trim();
+            if (!value) {
+                throw new Error("--origin-endpoint requires a URL");
+            }
+            originEndpointOverride = value;
+            continue;
+        }
+        if (arg === "--origin-token") {
+            const value = args[index + 1];
+            if (typeof value !== "string" || value.trim().length === 0) {
+                throw new Error("--origin-token requires a token");
+            }
+            originTokenOverride = value.trim();
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith("--origin-token=")) {
+            const value = arg.slice("--origin-token=".length).trim();
+            if (!value) {
+                throw new Error("--origin-token requires a token");
+            }
+            originTokenOverride = value;
+            continue;
+        }
+        if (arg === "--path") {
+            const value = args[index + 1];
+            if (typeof value !== "string" || value.trim().length === 0) {
+                throw new Error("--path requires a relative path");
+            }
+            paths.push(value.trim());
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith("--path=")) {
+            const value = arg.slice("--path=".length).trim();
+            if (!value) {
+                throw new Error("--path requires a relative path");
+            }
+            paths.push(value);
+            continue;
+        }
+        throw new Error(`Unknown argument: ${arg}`);
+    }
+    const originEndpoint = resolveOriginEndpoint(originEndpointOverride);
+    const originToken = resolveOriginToken(originTokenOverride);
+    const resolvedMessage = message ?? `instafy: sync ${new Date().toISOString().replace(/\..*$/, "")}Z`;
+    return {
+        message: resolvedMessage,
+        json,
+        originEndpoint,
+        originToken,
+        paths: paths.length > 0 ? paths : null,
+    };
+}
+export async function runInstafyGitSync(args, options) {
+    void options;
+    const parsed = parseGitSyncArgs(args);
+    if (parsed === "help") {
+        printGitSyncHelp();
+        return 0;
+    }
+    const url = `${parsed.originEndpoint.replace(/\/+$/, "")}/git/sync`;
+    const response = await fetch(url, {
+        method: "POST",
+        headers: {
+            accept: "application/json",
+            authorization: `Bearer ${parsed.originToken}`,
+            "content-type": "application/json",
+        },
+        body: JSON.stringify({
+            message: parsed.message,
+            paths: parsed.paths ?? undefined,
+        }),
+    }).catch((error) => {
+        throw new Error(`Origin git sync request failed: ${String(error)}`);
+    });
+    const text = await response.text().catch(() => "");
+    if (!response.ok) {
+        const suffix = text.trim() ? `: ${text.trim()}` : "";
+        console.error(kleur.red(`Origin git sync failed (${response.status} ${response.statusText})${suffix}`));
+        return 1;
+    }
+    const payload = text.trim() ? JSON.parse(text) : null;
+    const rev = typeof payload?.rev === "string" ? payload.rev.trim() : "";
+    if (!rev) {
+        console.error(kleur.red("Origin git sync response missing rev field."));
+        return 1;
+    }
+    if (parsed.json) {
+        console.log(JSON.stringify({ rev }, null, 2));
+    }
+    else {
+        console.log(rev);
+    }
+    return 0;
+}

package/dist/git.js

@@ -1,7 +1,8 @@
 import fs from "node:fs";
 import path from "node:path";
 import kleur from "kleur";
-import { resolveConfiguredAccessToken } from "./config.js";
+import { resolveConfiguredAccessToken, resolveControllerUrl } from "./config.js";
+import { formatAuthRejectedError } from "./errors.js";
 function normalizeToken(value) {
     if (typeof value !== "string") {
         return null;
@@ -25,6 +26,7 @@ function resolveControllerAccessToken(options) {
     return (normalizeToken(options.controllerAccessToken) ??
         normalizeToken(process.env["INSTAFY_ACCESS_TOKEN"]) ??
         normalizeToken(process.env["CONTROLLER_ACCESS_TOKEN"]) ??
+        normalizeToken(process.env["RUNTIME_ACCESS_TOKEN"]) ??
         normalizeToken(options.supabaseAccessToken) ??
         readTokenFromFile(options.supabaseAccessTokenFile) ??
         normalizeToken(process.env["SUPABASE_ACCESS_TOKEN"]) ??
@@ -43,6 +45,7 @@ export async function mintGitAccessToken(params) {
             authorization: `Bearer ${params.controllerAccessToken}`,
             "content-type": "application/json",
         },
+        signal: params.signal,
         body: JSON.stringify({
             scopes,
             ttlSeconds: params.ttlSeconds,
@@ -50,6 +53,12 @@ export async function mintGitAccessToken(params) {
     });
     if (!response.ok) {
         const text = await response.text().catch(() => "");
+        if (response.status === 401 || response.status === 403) {
+            throw formatAuthRejectedError({
+                status: response.status,
+                responseBody: text,
+            });
+        }
         throw new Error(`Instafy server rejected git token request (${response.status} ${response.statusText}): ${text}`);
     }
     const payload = (await response.json());
@@ -66,10 +75,7 @@ export async function mintGitAccessToken(params) {
     };
 }
 export async function gitToken(options) {
-    const controllerUrl = options.controllerUrl ??
-        process.env["INSTAFY_SERVER_URL"] ??
-        process.env["CONTROLLER_BASE_URL"] ??
-        "http://127.0.0.1:8788";
+    const controllerUrl = resolveControllerUrl({ controllerUrl: options.controllerUrl ?? null });
     const token = resolveControllerAccessToken({
         controllerAccessToken: options.controllerAccessToken,
         supabaseAccessToken: options.supabaseAccessToken,