rl-workspaces 0.0.0-stage → 0.6.0

package/dist/codex-sessions.js

@@ -0,0 +1,188 @@
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+import { canonical, object, sessionId, timestamp } from "./common.js";
+const SOURCES = ["cli", "vscode", "exec", "appServer"];
+// Ask Codex for workspace-filtered metadata only. Never read transcripts or
+// request a model turn, and never fall back to an unfiltered history query.
+async function discover(cwd, roots) {
+    const child = spawn("codex", ["app-server"], {
+        cwd,
+        stdio: ["pipe", "pipe", "ignore"],
+    });
+    const lines = createInterface({ input: child.stdout });
+    let requestId = 0;
+    let pending;
+    let failure;
+    let bytes = 0;
+    const fail = (error) => {
+        failure = error;
+        pending?.reject(error);
+        pending = undefined;
+        child.kill();
+    };
+    const timer = setTimeout(() => fail(new Error("Codex session discovery timed out")), 3000);
+    child.on("error", fail);
+    child.on("close", () => fail(new Error("Codex session discovery closed")));
+    child.stdin.on("error", fail);
+    child.stdout.on("data", (chunk) => {
+        bytes += chunk.length;
+        if (bytes > 8 * 1024 * 1024)
+            fail(new Error("Codex session metadata is too large"));
+    });
+    lines.on("line", (line) => {
+        try {
+            const reply = JSON.parse(line);
+            if (!object(reply) || reply.id !== pending?.id || !pending)
+                return;
+            if (reply.error !== undefined || !object(reply.result))
+                throw new Error("Codex rejected session discovery");
+            const request = pending;
+            pending = undefined;
+            request.resolve(reply.result);
+        }
+        catch (error) {
+            fail(error instanceof Error ? error : new Error(String(error)));
+        }
+    });
+    const request = (method, params) => new Promise((resolve, reject) => {
+        if (failure)
+            return reject(failure);
+        pending = { id: ++requestId, resolve, reject };
+        child.stdin.write(JSON.stringify({ id: requestId, method, params }) + "\n");
+    });
+    try {
+        await request("initialize", { clientInfo: { name: "rl", version: "1" } });
+        child.stdin.write(JSON.stringify({ method: "initialized" }) + "\n");
+        const sessions = [];
+        // A string cwd also works with older app-server versions.
+        for (const root of roots) {
+            let cursor;
+            const cursors = new Set();
+            do {
+                const result = await request("thread/list", {
+                    cwd: root,
+                    useStateDbOnly: true,
+                    sourceKinds: SOURCES,
+                    limit: 100,
+                    ...(cursor ? { cursor } : {}),
+                });
+                if (!Array.isArray(result.data))
+                    throw new Error("Invalid Codex thread list");
+                for (const thread of result.data) {
+                    if (!object(thread) ||
+                        thread.ephemeral === true ||
+                        (thread.source !== undefined &&
+                            (typeof thread.source !== "string" ||
+                                !SOURCES.includes(thread.source))) ||
+                        typeof thread.cwd !== "string" ||
+                        canonical(thread.cwd) !== root)
+                        continue;
+                    // Only UUIDs can be passed unambiguously to the installed resume CLI.
+                    try {
+                        if (typeof thread.createdAt !== "number" ||
+                            typeof thread.updatedAt !== "number")
+                            continue;
+                        const createdAt = new Date(thread.createdAt * 1000).toISOString();
+                        const lastUsedAt = new Date(thread.updatedAt * 1000).toISOString();
+                        sessions.push({
+                            id: sessionId(thread.id),
+                            cwd: root,
+                            createdAt,
+                            lastUsedAt,
+                            branch: object(thread.gitInfo) &&
+                                typeof thread.gitInfo.branch === "string"
+                                ? thread.gitInfo.branch
+                                : undefined,
+                        });
+                    }
+                    catch {
+                        /* Unsupported identifiers or invalid timestamps are not resume targets. */
+                    }
+                }
+                if (result.nextCursor !== null &&
+                    result.nextCursor !== undefined &&
+                    typeof result.nextCursor !== "string")
+                    throw new Error("Invalid Codex thread cursor");
+                cursor = result.nextCursor;
+                if (cursor && cursors.has(cursor))
+                    throw new Error("Repeated Codex thread cursor");
+                if (cursor)
+                    cursors.add(cursor);
+            } while (cursor);
+        }
+        return sessions;
+    }
+    finally {
+        clearTimeout(timer);
+        lines.close();
+        child.stdin.end();
+        child.kill();
+    }
+}
+export async function syncCodexSessions(store, cwd) {
+    const records = await store.locked(() => cwd
+        ? [store.current(cwd)]
+        : store.records().filter(([, data]) => data.status === "active"));
+    const eligible = records.filter(([, data]) => {
+        try {
+            return store.current(data.worktree)[1].key === data.key;
+        }
+        catch {
+            return false;
+        }
+    });
+    if (!eligible.length)
+        return;
+    let sessions;
+    try {
+        sessions = await discover(eligible[0][1].worktree, eligible.map(([, data]) => data.worktree));
+    }
+    catch {
+        // Missing/older Codex or a temporarily unavailable server must not hide RL
+        // status or erase already saved sessions. Hooks/manual save still work.
+        return;
+    }
+    await store.locked(() => {
+        for (const [file, snapshot] of eligible) {
+            let current;
+            try {
+                current = store.current(snapshot.worktree);
+            }
+            catch {
+                continue;
+            }
+            const [currentFile, data] = current;
+            if (currentFile !== file || data.key !== snapshot.key)
+                continue;
+            let changed = false;
+            for (const session of sessions) {
+                if (session.cwd !== data.worktree ||
+                    (session.branch !== undefined && session.branch !== data.branch) ||
+                    (session.branch === undefined &&
+                        timestamp(session.createdAt) < timestamp(data.createdAt)))
+                    continue;
+                try {
+                    store.assertSessionOwner(file, "codex", session.id);
+                }
+                catch {
+                    continue;
+                }
+                const saved = data.sessions.codex.find((item) => item.id === session.id);
+                if (!saved) {
+                    data.sessions.codex.push({
+                        id: session.id,
+                        createdAt: session.createdAt,
+                        lastUsedAt: session.lastUsedAt,
+                    });
+                    changed = true;
+                }
+                else if (timestamp(session.lastUsedAt) > timestamp(saved.lastUsedAt)) {
+                    saved.lastUsedAt = session.lastUsedAt;
+                    changed = true;
+                }
+            }
+            if (changed)
+                store.save(file, data);
+        }
+    });
+}

package/dist/command-context.js

@@ -0,0 +1,67 @@
+import path from "node:path";
+import fs from "node:fs";
+import os from "node:os";
+import { canonical, inside, required } from "./common.js";
+import { candidates } from "./picker.js";
+import { Store } from "./store.js";
+export const contextOptions = ["repo", "state-dir", "base-dir", "default-base"];
+export function writeWorkspaceOutput(workspace, output) {
+    if (output === undefined) {
+        console.log(workspace);
+        return;
+    }
+    const target = path.resolve(output);
+    if (!inside(canonical(target), canonical(os.tmpdir())))
+        throw new Error("Shell output file must be inside the temporary directory");
+    const fd = fs.openSync(target, fs.constants.O_WRONLY | fs.constants.O_NOFOLLOW);
+    try {
+        const stat = fs.fstatSync(fd);
+        if (!stat.isFile() || stat.size !== 0 || stat.nlink !== 1)
+            throw new Error("Shell output file must be an empty regular file");
+        fs.writeFileSync(fd, workspace);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+/** Settings have already been selected by the public CLI's repository router. */
+export function commandContext(values) {
+    const repo = required(values, "repo"), stateDir = required(values, "state-dir"), managedDir = required(values, "base-dir");
+    if (![repo, stateDir, managedDir].every((value) => path.isAbsolute(value)))
+        throw new Error("Repository, state and managed workspace paths must be absolute");
+    const store = new Store(repo, stateDir);
+    return {
+        repo: store.repo,
+        stateDir: store.stateDir,
+        managedDir: canonical(managedDir),
+        defaultBase: String(values["default-base"] ?? "origin/test"),
+        store,
+    };
+}
+/** Resolve only the current checkout or registered managed worktrees, never scan. */
+export function resolveWorkspace(context, selector) {
+    if (!selector) {
+        const [root, branch] = context.store.worktree(process.cwd());
+        return { path: root, name: path.basename(root), branch };
+    }
+    if (selector === "@" ||
+        (path.isAbsolute(selector) && canonical(selector) === context.repo)) {
+        const [root, branch] = context.store.worktree(context.repo);
+        return { path: root, name: "@", branch };
+    }
+    const choices = candidates(context.repo, context.managedDir);
+    const matches = choices.filter((item) => item.name === selector ||
+        item.branch === selector ||
+        (path.isAbsolute(selector) && item.path === canonical(selector)));
+    if (matches.length !== 1)
+        throw new Error(matches.length
+            ? `Ambiguous workspace: ${selector}; use its managed directory name`
+            : `Workspace not found: ${selector}. Use rl list or rl switch --create.`);
+    const item = matches[0];
+    // Revalidate repository identity and branch. Worktree metadata alone can be
+    // stale after the directory has been removed or replaced.
+    const [root, branch] = context.store.worktree(item.path);
+    if (branch !== item.branch)
+        throw new Error("Workspace branch changed during selection; retry the command");
+    return { path: root, name: item.name, branch };
+}

package/dist/common.js

@@ -0,0 +1,262 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { randomUUID } from "node:crypto";
+import { spawnSync, spawn } from "node:child_process";
+import { parseArgs } from "node:util";
+import lockfile from "proper-lockfile";
+import { readJsonObject } from "./json.js";
+export const now = () => new Date().toISOString();
+export const message = (error) => error instanceof Error ? error.message : String(error);
+export const json = (data) => console.log(JSON.stringify(data, null, 2));
+export function canonical(value) {
+    const absolute = path.resolve(value);
+    try {
+        return fs.realpathSync(absolute);
+    }
+    catch (error) {
+        if (!["ENOENT", "ENOTDIR"].includes(error.code ?? ""))
+            throw error;
+        const parent = path.dirname(absolute);
+        return parent === absolute
+            ? absolute
+            : path.join(canonical(parent), path.basename(absolute));
+    }
+}
+export const expandHome = (value) => value === "~"
+    ? os.homedir()
+    : value.startsWith("~/")
+        ? path.join(os.homedir(), value.slice(2))
+        : value;
+export function inside(child, parent) {
+    const relative = path.relative(parent, child);
+    return (!!relative &&
+        relative !== ".." &&
+        !relative.startsWith(`..${path.sep}`) &&
+        !path.isAbsolute(relative));
+}
+export function gitEnv() {
+    const env = { ...process.env };
+    for (const key of [
+        "GIT_DIR",
+        "GIT_WORK_TREE",
+        "GIT_COMMON_DIR",
+        "GIT_INDEX_FILE",
+    ])
+        delete env[key];
+    return env;
+}
+export function run(argv, cwd, raw = false) {
+    const result = spawnSync(argv[0], argv.slice(1), {
+        cwd,
+        encoding: "utf8",
+        env: argv[0] === "git" ? gitEnv() : process.env,
+        maxBuffer: 32 * 1024 * 1024,
+    });
+    if (result.error)
+        throw result.error;
+    if (result.status !== 0)
+        throw new Error(result.stderr.trim() || `Command failed: ${argv.join(" ")}`);
+    return raw ? result.stdout : result.stdout.trim();
+}
+export const git = (cwd, ...args) => run(["git", "-C", cwd, ...args], cwd);
+export const gitRaw = (cwd, ...args) => run(["git", "-C", cwd, ...args], cwd, true);
+export async function execute(argv, cwd, options = {}) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(argv[0], argv.slice(1), {
+            cwd,
+            timeout: options.timeoutMs,
+            env: options.env ?? (argv[0] === "git" ? gitEnv() : process.env),
+            detached: options.processGroup,
+            stdio: options.interactive
+                ? "inherit"
+                : ["pipe", "pipe", options.terminalError ? "inherit" : "pipe"],
+        });
+        let stdout = "", stderr = "";
+        let outputBytes = 0;
+        let overflow = false;
+        let forceKill;
+        const kill = (signal) => {
+            if (child.exitCode !== null || child.signalCode !== null)
+                return;
+            try {
+                if (options.processGroup && child.pid)
+                    process.kill(-child.pid, signal);
+                else
+                    child.kill(signal);
+            }
+            catch (error) {
+                const code = error.code;
+                if (code === "EPERM" && options.processGroup)
+                    child.kill(signal);
+                else if (code !== "ESRCH")
+                    throw error;
+            }
+        };
+        const abort = () => {
+            kill("SIGTERM");
+            forceKill ??= setTimeout(() => kill("SIGKILL"), 1000);
+            forceKill.unref();
+        };
+        const append = (chunk, target) => {
+            outputBytes += chunk.length;
+            if (options.maxOutputBytes && outputBytes > options.maxOutputBytes) {
+                overflow = true;
+                abort();
+            }
+            else if (target === "stdout")
+                stdout += chunk;
+            else
+                stderr += chunk;
+        };
+        child.stdout?.on("data", (chunk) => {
+            append(chunk, "stdout");
+        });
+        child.stderr?.on("data", (chunk) => {
+            append(chunk, "stderr");
+        });
+        child.stdin?.on("error", () => { });
+        child.stdin?.end(options.input);
+        const interrupt = () => child.kill("SIGINT");
+        const terminate = () => child.kill("SIGTERM");
+        process.on("SIGINT", interrupt);
+        process.on("SIGTERM", terminate);
+        const cleanup = () => {
+            if (forceKill)
+                clearTimeout(forceKill);
+            options.signal?.removeEventListener("abort", abort);
+            process.off("SIGINT", interrupt);
+            process.off("SIGTERM", terminate);
+        };
+        child.on("error", (error) => {
+            cleanup();
+            reject(error);
+        });
+        child.on("close", (code, signal) => {
+            cleanup();
+            if (overflow) {
+                reject(new Error("Command output exceeded the configured size limit"));
+                return;
+            }
+            resolve({
+                code: code ?? 128 + (os.constants.signals[signal] ?? 1),
+                stdout,
+                stderr,
+            });
+        });
+        options.signal?.addEventListener("abort", abort, { once: true });
+        if (options.signal?.aborted)
+            abort();
+    });
+}
+export function object(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+export function readJson(file) {
+    return readJsonObject(file);
+}
+export function atomicWrite(file, text) {
+    fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+    const temporary = path.join(path.dirname(file), `.rl-${randomUUID()}`);
+    try {
+        const fd = fs.openSync(temporary, "wx", 0o600);
+        try {
+            fs.writeFileSync(fd, text);
+            fs.fsyncSync(fd);
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+        fs.renameSync(temporary, file);
+    }
+    finally {
+        if (fs.existsSync(temporary))
+            fs.unlinkSync(temporary);
+    }
+}
+export const writeJson = (file, data) => atomicWrite(file, JSON.stringify(data, null, 2) + "\n");
+export async function locked(directory, name, action) {
+    fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
+    const release = await lockfile.lock(directory, {
+        realpath: false,
+        lockfilePath: path.join(directory, name),
+        stale: 120000,
+        retries: { retries: 300, factor: 1, minTimeout: 25, maxTimeout: 100 },
+    });
+    try {
+        return await action();
+    }
+    finally {
+        await release();
+    }
+}
+export function shellQuote(value) {
+    return /^[\w@%+=:,./-]+$/.test(value)
+        ? value
+        : "'" + value.replaceAll("'", "'\"'\"'") + "'";
+}
+export function sessionId(value) {
+    if (typeof value !== "string" ||
+        !/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/i.test(value))
+        throw new Error("Expected the agent's full session UUID, not a name or prefix");
+    return value.toLowerCase();
+}
+// Normalize timezone offsets while retaining Python's microsecond timestamp precision.
+export function timestamp(value) {
+    if (!/(?:Z|[+-]\d{2}:\d{2})$/.test(value) ||
+        !Number.isFinite(Date.parse(value)))
+        throw new Error("Invalid timestamp");
+    const fraction = /\.(\d+)/.exec(value)?.[1] ?? "";
+    return (BigInt(Date.parse(value)) * 1000000n +
+        BigInt(fraction.slice(3, 9).padEnd(6, "0")));
+}
+export function args(argv, strings, booleans = [], short = {}) {
+    const options = {};
+    for (const name of strings)
+        options[name] = {
+            type: "string",
+            ...(short[name] ? { short: short[name] } : {}),
+        };
+    for (const name of booleans)
+        options[name] = {
+            type: "boolean",
+            ...(short[name] ? { short: short[name] } : {}),
+        };
+    return parseArgs({
+        args: argv,
+        options,
+        allowPositionals: true,
+        strict: true,
+    });
+}
+export function required(values, key) {
+    const value = values[key];
+    if (typeof value !== "string" || !value)
+        throw new Error(`Missing --${key}`);
+    return value;
+}
+export function arity(values, min, max = min) {
+    if (values.length < min || values.length > max)
+        throw new Error("Invalid command arguments; run rl --help");
+}
+export async function pooled(items, limit, action) {
+    const results = new Array(items.length);
+    let next = 0;
+    await Promise.all(Array.from({ length: Math.min(limit, items.length) }, async () => {
+        while (next < items.length) {
+            const index = next++;
+            results[index] = await action(items[index]);
+        }
+    }));
+    return results;
+}
+export const isSymlink = (file) => {
+    try {
+        return fs.lstatSync(file).isSymbolicLink();
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+};

package/dist/delete.js

@@ -0,0 +1,113 @@
+import path from "node:path";
+import { args, canonical, execute, git, inside, locked, message, pooled, required, } from "./common.js";
+import { Store } from "./store.js";
+import { worktrees } from "./repos.js";
+import { candidates, select } from "./picker.js";
+import { assertReady, GIT_WORKFLOW_DIRECTORY, GIT_WORKFLOW_LOCK, } from "./git-safety.js";
+export async function main(argv) {
+    const { values, positionals } = args(argv, ["repo", "state-dir", "base-dir", "jobs", "default-base"], ["dry-run", "force"]);
+    const jobs = Number(values.jobs ?? 4);
+    if (!Number.isInteger(jobs) || jobs < 1 || jobs > 32)
+        throw new Error("jobs must be an integer from 1 to 32");
+    const repo = canonical(required(values, "repo")), base = canonical(required(values, "base-dir")), registered = worktrees(repo), items = new Map();
+    for (const item of candidates(repo, base))
+        items.set(item.name, item);
+    let names = positionals;
+    if (!names.length)
+        names = (await select(new Store(repo, required(values, "state-dir")), [...items.values()], String(values["default-base"] ?? "origin/test"), true)).map((item) => item.name);
+    names = [...new Set(names)];
+    if (!names.length)
+        return 0;
+    const unknown = names.filter((name) => !items.has(name));
+    if (unknown.length)
+        throw new Error("Not registered managed worktrees: " + unknown.join(", "));
+    const selected = names.map((name) => items.get(name));
+    for (const item of selected)
+        if (registered.some((other) => inside(canonical(other.worktree), item.path)))
+            throw new Error(`${item.name} contains another registered worktree; delete its children first`);
+    for (const item of selected)
+        console.log(`${values["dry-run"] ? "Would delete" : "Selected"}: ${item.name} [branch: ${item.branch || "(detached)"}]${item.locked ? " [locked: will be skipped]" : ""}`);
+    if (values["dry-run"])
+        return 0;
+    const store = new Store(repo, required(values, "state-dir"));
+    return locked(path.join(store.root, GIT_WORKFLOW_DIRECTORY), GIT_WORKFLOW_LOCK, async () => {
+        await store.locked(() => store.records());
+        process.chdir(repo);
+        console.log(`Removing ${selected.length} workspace(s), up to ${jobs} at a time...`);
+        const removed = [], failed = [];
+        await pooled(selected, jobs, async (item) => {
+            try {
+                const current = worktrees(repo).find((entry) => canonical(entry.worktree) === item.path);
+                if (!current ||
+                    (current.branch ?? "").replace(/^refs\/heads\//, "") !== item.branch)
+                    throw new Error("Workspace branch changed; inspect it and retry");
+                if (!values.force && !item.branch)
+                    throw new Error("Detached workspace may contain unmerged commits; inspect it or use --force");
+                if (!values.force)
+                    assertReady(item.path, true, item.branch);
+                if (!values.force && item.branch) {
+                    const upstream = git(repo, "for-each-ref", "--format=%(upstream)", `refs/heads/${item.branch}`);
+                    const merged = await execute([
+                        "git",
+                        "-C",
+                        repo,
+                        "merge-base",
+                        "--is-ancestor",
+                        `refs/heads/${item.branch}`,
+                        upstream || "HEAD",
+                    ], repo);
+                    if (merged.code)
+                        throw new Error("Branch has unmerged commits; merge it first or use --force");
+                }
+                const result = await execute([
+                    "git",
+                    "-C",
+                    repo,
+                    "worktree",
+                    "remove",
+                    ...(values.force ? ["--force"] : []),
+                    item.path,
+                ], repo);
+                if (result.code)
+                    throw new Error(result.stderr.trim());
+                removed.push(item);
+                console.log(`Removed worktree: ${item.name}`);
+            }
+            catch (error) {
+                failed.push(item);
+                console.error(`Failed: ${item.name}: ${message(error)}`);
+            }
+        });
+        await store.locked(() => store.archiveWorktrees(removed.map((item) => item.path)));
+        let cleanupFailed = false;
+        const branches = [
+            ...new Set(removed.map((item) => item.branch).filter(Boolean)),
+        ];
+        if (branches.length) {
+            const result = await execute([
+                "git",
+                "-C",
+                repo,
+                "branch",
+                values.force ? "-D" : "-d",
+                "--",
+                ...branches,
+            ], repo);
+            process.stdout.write(result.stdout);
+            if (result.code) {
+                cleanupFailed = true;
+                console.error("Some worktrees were removed but local branch cleanup failed:\n" +
+                    result.stderr.trim());
+            }
+        }
+        if (removed.length) {
+            const result = await execute(["git", "-C", repo, "worktree", "prune"], repo);
+            if (result.code) {
+                cleanupFailed = true;
+                console.error("Worktree pruning failed: " + result.stderr.trim());
+            }
+        }
+        console.log(`Removed ${removed.length} worktree(s); failed ${failed.length}. Saved documentation and session history retained.`);
+        return failed.length || cleanupFailed ? 1 : 0;
+    });
+}