codelocal 1.5.0-beta.1

package/dist/cloud-client-sync.js

@@ -0,0 +1,6 @@
+// MCP configuration is intentionally local-only.
+// This compatibility shim remains so older compiled entrypoints fail closed
+// instead of attempting to fetch MCP metadata from CodeLocal Cloud.
+export async function syncCloudMcpBeforeClient() {
+    return { skipped: true, reason: "MCP configuration is local-only" };
+}

package/dist/context-engine.js

@@ -0,0 +1,295 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { WorkspaceIntelligenceIndex } from "./workspace-index.js";
+const MAX_CONTEXT_CHARS = Math.max(8_000, Number(process.env.CODELOCAL_CONTEXT_MAX_CHARS ?? 48_000) || 48_000);
+const MAX_SNIPPET_CHARS = Math.max(1_000, Number(process.env.CODELOCAL_CONTEXT_SNIPPET_CHARS ?? 7_000) || 7_000);
+const MAX_CONTEXT_FILES = Math.max(2, Number(process.env.CODELOCAL_CONTEXT_FILES ?? 8) || 8);
+function unique(values) {
+    return [...new Set(values)];
+}
+function normalizeLanguage(language) {
+    if (!language)
+        return null;
+    if (language === "typescript" || language === "javascript")
+        return "typescript/javascript";
+    if (language === "c" || language === "cpp")
+        return "c/c++";
+    return language;
+}
+function taskTerms(taskHint) {
+    return unique(taskHint.toLowerCase().split(/[^a-z0-9_$-]+/).filter((value) => value.length >= 2)).slice(0, 14);
+}
+function symbolMatches(symbol, terms) {
+    const name = (symbol.name ?? "").toLowerCase();
+    const file = symbol.path.toLowerCase();
+    return terms.some((term) => name.includes(term) || file.includes(term));
+}
+export class ProjectContextEngine {
+    root;
+    semantic;
+    intelligence;
+    cached = null;
+    epoch = 0;
+    constructor(root, semantic, intelligence = new WorkspaceIntelligenceIndex(root)) {
+        this.root = root;
+        this.semantic = semantic;
+        this.intelligence = intelligence;
+    }
+    invalidate(paths) {
+        this.cached = null;
+        this.epoch++;
+        this.intelligence.invalidate(paths);
+    }
+    noteChange(relativePath) {
+        this.cached = null;
+        this.epoch++;
+        this.intelligence.noteChange(relativePath);
+    }
+    indexSummary() {
+        return this.intelligence.summary();
+    }
+    async refresh(force = false) {
+        const summary = await this.intelligence.ensureFresh(force);
+        if (force)
+            this.cached = null;
+        return summary;
+    }
+    async packageMetadata(manifests) {
+        const frameworks = new Set();
+        const scriptCommands = new Map();
+        const packageFiles = manifests.filter((file) => file.endsWith("package.json")).slice(0, 80);
+        for (const relative of packageFiles) {
+            try {
+                const parsed = JSON.parse(await fs.readFile(path.join(this.root, relative), "utf8"));
+                const deps = { ...(parsed?.dependencies ?? {}), ...(parsed?.devDependencies ?? {}) };
+                for (const name of ["next", "@nestjs/core", "react", "vue", "@angular/core", "express", "fastify", "svelte", "nuxt", "expo", "react-native"]) {
+                    if (name in deps)
+                        frameworks.add(name);
+                }
+                const scripts = parsed?.scripts ?? {};
+                const dir = path.posix.dirname(relative) === "." ? "." : path.posix.dirname(relative);
+                for (const [name] of Object.entries(scripts)) {
+                    const list = scriptCommands.get(name) ?? [];
+                    list.push(dir);
+                    scriptCommands.set(name, list);
+                }
+            }
+            catch { }
+        }
+        return { frameworks: [...frameworks], scriptCommands };
+    }
+    async map(force = false) {
+        const indexSummary = await this.intelligence.ensureFresh(force);
+        if (this.cached && !force && this.cached.intelligence.builtAt === indexSummary.builtAt && this.cached.intelligence.dirty === indexSummary.dirty)
+            return this.cached;
+        const records = this.intelligence.allFiles();
+        const files = records.map((record) => record.path);
+        const manifests = records.filter((record) => record.kind === "manifest").map((record) => record.path);
+        const lockfiles = files.filter((file) => /(^|\/)(package-lock\.json|pnpm-lock\.yaml|yarn\.lock|bun\.lockb?|poetry\.lock|uv\.lock|Cargo\.lock|go\.sum|composer\.lock|pubspec\.lock|Gemfile\.lock|Podfile\.lock)$/i.test(file));
+        const languages = unique(records.map((record) => normalizeLanguage(record.language)).filter((value) => !!value));
+        const packageMeta = await this.packageMetadata(manifests);
+        const frameworks = [...packageMeta.frameworks];
+        for (const relative of manifests.filter((file) => file.endsWith("pyproject.toml")).slice(0, 20)) {
+            const py = await fs.readFile(path.join(this.root, relative), "utf8").catch(() => "");
+            if (/fastapi/i.test(py))
+                frameworks.push("fastapi");
+            if (/django/i.test(py))
+                frameworks.push("django");
+            if (/flask/i.test(py))
+                frameworks.push("flask");
+        }
+        if (manifests.some((file) => file.endsWith("pubspec.yaml")))
+            frameworks.push("flutter/dart");
+        if (files.some((file) => /(^|\/)ios\/Runner\.xcodeproj\//.test(file)))
+            frameworks.push("ios/xcode");
+        const packageManager = files.some((file) => /(^|\/)pnpm-lock\.yaml$/.test(file)) ? "pnpm"
+            : files.some((file) => /(^|\/)yarn\.lock$/.test(file)) ? "yarn"
+                : files.some((file) => /(^|\/)bun\.lockb?$/.test(file)) ? "bun"
+                    : files.some((file) => /(^|\/)package-lock\.json$/.test(file)) ? "npm"
+                        : null;
+        const scriptCommand = (name, dir) => {
+            const runner = packageManager === "npm" ? `npm run ${name}` : packageManager ? `${packageManager} ${name}` : `npm run ${name}`;
+            return dir === "." ? runner : `cd ${dir} && ${runner}`;
+        };
+        const commandsFor = (pattern) => [...packageMeta.scriptCommands.entries()]
+            .filter(([name]) => pattern.test(name))
+            .flatMap(([name, dirs]) => dirs.map((dir) => scriptCommand(name, dir)));
+        const buildCommands = commandsFor(/^(build|compile)(:|$)/);
+        const testCommands = commandsFor(/^(test)(:|$)/);
+        const lintCommands = commandsFor(/^(lint)(:|$)/);
+        const typecheckCommands = commandsFor(/^(typecheck|check)(:|$)/);
+        if (manifests.some((file) => file.endsWith("Cargo.toml"))) {
+            buildCommands.push("cargo check");
+            testCommands.push("cargo test");
+        }
+        if (manifests.some((file) => file.endsWith("go.mod"))) {
+            buildCommands.push("go build ./...");
+            testCommands.push("go test ./...");
+        }
+        if (manifests.some((file) => /pyproject|requirements/.test(file)))
+            testCommands.push("pytest");
+        if (manifests.some((file) => file.endsWith("pubspec.yaml"))) {
+            buildCommands.push("flutter analyze");
+            testCommands.push("flutter test");
+        }
+        const workspaceRoots = unique(manifests.map((file) => path.posix.dirname(file)).map((dir) => dir === "." ? "." : dir));
+        const rootsFromFiles = unique(files.map((file) => file.split("/")[0]).filter((name) => ["src", "app", "apps", "packages", "lib", "cmd", "internal", "pkg", "crates"].includes(name)));
+        const sourceRoots = unique([
+            ...rootsFromFiles,
+            ...workspaceRoots.flatMap((workspace) => ["lib", "src", "app"].map((name) => workspace === "." ? name : `${workspace}/${name}`).filter((candidate) => files.some((file) => file.startsWith(`${candidate}/`)))),
+        ]);
+        const testRoots = unique(files.map((file) => file.split("/").slice(0, -1).join("/")).filter((dir) => /(^|\/)(__tests__|test|tests|spec|specs)$/.test(dir))).slice(0, 200);
+        const entrypoints = files.filter((file) => /(^|\/)(main|index|server|app)\.(ts|tsx|js|jsx|py|rs|go|java|kt|cs|php|dart|swift)$/i.test(file)).slice(0, 150);
+        const instructionFiles = files.filter((file) => /(^|\/)(AGENTS\.md|CLAUDE\.md|copilot-instructions\.md)$/i.test(file));
+        const moduleCandidates = new Set();
+        for (const rootName of sourceRoots.length ? sourceRoots : ["src", "lib"]) {
+            for (const file of files) {
+                if (!file.startsWith(`${rootName}/`))
+                    continue;
+                const rest = file.slice(rootName.length + 1);
+                const first = rest.split("/")[0];
+                if (first && !first.includes("."))
+                    moduleCandidates.add(`${rootName}/${first}`);
+            }
+        }
+        this.cached = {
+            generatedAt: Date.now(),
+            rootName: path.basename(this.root),
+            languages,
+            frameworks: unique(frameworks),
+            workspaceRoots: workspaceRoots.length ? workspaceRoots : ["."],
+            entrypoints,
+            sourceRoots,
+            testRoots,
+            manifests,
+            lockfiles,
+            buildCommands: unique(buildCommands),
+            testCommands: unique(testCommands),
+            lintCommands: unique(lintCommands),
+            typecheckCommands: unique(typecheckCommands),
+            instructionFiles,
+            modules: [...moduleCandidates].slice(0, 300),
+            packageManager,
+            intelligence: indexSummary,
+        };
+        return this.cached;
+    }
+    async lspSymbolsForFiles(paths, terms, limit) {
+        const symbols = [];
+        for (const relative of paths.slice(0, Math.min(10, paths.length))) {
+            const document = await this.semantic.documentSymbols(relative, 160).catch(() => []);
+            const matches = terms.length ? document.filter((symbol) => symbolMatches(symbol, terms)) : document.slice(0, 12);
+            symbols.push(...(matches.length ? matches : document.slice(0, 5)));
+            if (symbols.length >= limit)
+                break;
+        }
+        return symbols.slice(0, limit);
+    }
+    async diagnosticsForFiles(paths, limit = 40) {
+        const diagnostics = [];
+        for (const relative of paths.slice(0, 5)) {
+            const values = await this.semantic.diagnostics(relative, 20).catch(() => []);
+            diagnostics.push(...values.map((item) => ({ ...item, path: item.path ?? relative })));
+            if (diagnostics.length >= limit)
+                break;
+        }
+        return diagnostics.slice(0, limit);
+    }
+    async snippet(relativePath, preferredLine, reason) {
+        try {
+            const absolute = path.resolve(this.root, relativePath);
+            const stat = await fs.stat(absolute);
+            if (!stat.isFile() || stat.size > 2 * 1024 * 1024)
+                return null;
+            const text = await fs.readFile(absolute, "utf8");
+            if (text.includes("\u0000"))
+                return null;
+            const lines = text.split(/\r?\n/);
+            const center = Math.max(1, Math.min(lines.length, preferredLine ?? 1));
+            const radius = preferredLine ? 24 : 32;
+            let startLine = Math.max(1, center - radius);
+            let endLine = Math.min(lines.length, center + radius);
+            let content = lines.slice(startLine - 1, endLine).join("\n");
+            if (content.length > MAX_SNIPPET_CHARS) {
+                content = content.slice(0, MAX_SNIPPET_CHARS);
+                const keptLines = content.split(/\r?\n/).length;
+                endLine = Math.min(endLine, startLine + keptLines - 1);
+            }
+            return { path: relativePath, startLine, endLine, totalLines: lines.length, content, reason };
+        }
+        catch {
+            return null;
+        }
+    }
+    async relevant(taskHint, limit = 30) {
+        const project = await this.map();
+        await this.intelligence.ensureFresh();
+        const terms = taskTerms(taskHint);
+        const rankedFiles = this.intelligence.rank(taskHint, Math.max(limit * 3, 60));
+        const rankedPaths = rankedFiles.map((file) => file.path);
+        const workspaceSymbols = [];
+        for (const term of terms.slice(0, 10)) {
+            const found = await this.semantic.workspaceSymbols(term, Math.max(8, Math.ceil(limit / Math.max(1, terms.length))));
+            workspaceSymbols.push(...found);
+            if (workspaceSymbols.length >= limit * 2)
+                break;
+        }
+        const lspSymbols = await this.lspSymbolsForFiles(rankedPaths, terms, limit * 2);
+        const symbols = [...workspaceSymbols, ...lspSymbols].filter((symbol, index, all) => all.findIndex((candidate) => candidate.path === symbol.path && candidate.line === symbol.line && candidate.name === symbol.name) === index);
+        const symbolPaths = unique(symbols.map((symbol) => symbol.path).filter(Boolean));
+        const graphNeighbors = this.intelligence.neighbors([...rankedPaths.slice(0, 12), ...symbolPaths.slice(0, 12)], limit * 3);
+        const relevantPaths = unique([...rankedPaths, ...symbolPaths, ...graphNeighbors]).slice(0, limit);
+        const rankingByPath = new Map(rankedFiles.map((file) => [file.path, file]));
+        const diagnostics = await this.diagnosticsForFiles(relevantPaths);
+        const relevantSet = new Set(relevantPaths);
+        const graphEdges = this.intelligence.graph(5000)
+            .filter((edge) => relevantSet.has(edge.from) || relevantSet.has(edge.to))
+            .slice(0, 120);
+        const snippets = [];
+        let usedChars = 0;
+        for (const relative of relevantPaths.slice(0, MAX_CONTEXT_FILES)) {
+            const symbol = symbols.find((item) => item.path === relative && symbolMatches(item, terms)) ?? symbols.find((item) => item.path === relative);
+            const diagnostic = diagnostics.find((item) => item.path === relative);
+            const ranked = rankingByPath.get(relative);
+            const preferredLine = symbol?.line ?? diagnostic?.line;
+            const reason = ranked?.reasons?.join(", ") || (symbol ? "semantic-symbol" : diagnostic ? "diagnostic" : "graph-neighbor");
+            const value = await this.snippet(relative, preferredLine, reason);
+            if (!value)
+                continue;
+            if (usedChars + value.content.length > MAX_CONTEXT_CHARS)
+                break;
+            snippets.push(value);
+            usedChars += value.content.length;
+        }
+        return {
+            taskHint,
+            strategy: "persistent-incremental-index + per-root-LSP + semantic-symbols + dependency-neighbors + recent-change-ranking + bounded-source-snippets",
+            epoch: this.epoch,
+            index: this.intelligence.summary(),
+            project: {
+                languages: project.languages,
+                frameworks: project.frameworks,
+                workspaceRoots: project.workspaceRoots,
+                sourceRoots: project.sourceRoots,
+                testRoots: project.testRoots,
+                entrypoints: project.entrypoints.slice(0, 30),
+                commands: { build: project.buildCommands, test: project.testCommands, lint: project.lintCommands, typecheck: project.typecheckCommands },
+            },
+            rankedFiles: relevantPaths.map((file) => {
+                const ranked = rankingByPath.get(file);
+                return ranked
+                    ? { path: file, score: ranked.score, reasons: ranked.reasons, language: ranked.language, symbols: ranked.symbols.slice(0, 20), imports: ranked.imports.slice(0, 20), changedAt: ranked.changedAt }
+                    : { path: file, score: null, reasons: [symbolPaths.includes(file) ? "semantic-symbol" : "graph-neighbor"] };
+            }),
+            symbols: symbols.slice(0, limit * 2),
+            diagnostics,
+            graphEdges,
+            snippets,
+            relevantPaths,
+            contextBudget: { maxChars: MAX_CONTEXT_CHARS, usedChars, maxFiles: MAX_CONTEXT_FILES },
+            recommendation: relevantPaths.length
+                ? "Use this packet first. Ask for exact definitions/references or read a larger range only when the packet is insufficient; all side effects remain separate MCP calls."
+                : "Narrow the task hint or use semantic/text search before any broad scan.",
+        };
+    }
+}

package/dist/editing-engine.js

@@ -0,0 +1,205 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+import { spawn } from "node:child_process";
+import { isSensitivePath } from "./security-policy.js";
+function sha256(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+function offsetAt(text, line, column) {
+    const lines = text.split(/(?<=\n)/);
+    const row = Math.max(1, line);
+    const col = Math.max(1, column);
+    let offset = 0;
+    for (let i = 0; i < row - 1 && i < lines.length; i++)
+        offset += lines[i].length;
+    return Math.min(text.length, offset + col - 1);
+}
+async function executable(file) {
+    return fs.access(file).then(() => true).catch(() => false);
+}
+async function run(command, args, cwd, timeoutMs = 120_000) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, { cwd, env: { ...process.env }, stdio: ["ignore", "pipe", "pipe"] });
+        let stdout = "", stderr = "", done = false;
+        const timer = setTimeout(() => { if (!done)
+            child.kill("SIGTERM"); }, timeoutMs);
+        child.stdout.on("data", (d) => { stdout = (stdout + d.toString()).slice(-1_000_000); });
+        child.stderr.on("data", (d) => { stderr = (stderr + d.toString()).slice(-1_000_000); });
+        child.on("error", reject);
+        child.on("close", (code) => { done = true; clearTimeout(timer); resolve({ code, stdout, stderr }); });
+    });
+}
+export class EditingEngine {
+    root;
+    constructor(root) {
+        this.root = root;
+    }
+    lexical(relativePath) {
+        if (path.isAbsolute(relativePath))
+            throw new Error("Absolute paths are not allowed.");
+        if (isSensitivePath(relativePath))
+            throw new Error(`Access blocked by sensitive-path policy: ${relativePath}`);
+        const candidate = path.resolve(this.root, relativePath);
+        const prefix = this.root.endsWith(path.sep) ? this.root : this.root + path.sep;
+        if (candidate !== this.root && !candidate.startsWith(prefix))
+            throw new Error("Path escapes PROJECT_ROOT.");
+        return candidate;
+    }
+    async existing(relativePath) {
+        const candidate = this.lexical(relativePath);
+        const real = await fs.realpath(candidate);
+        const realRoot = await fs.realpath(this.root);
+        const prefix = realRoot.endsWith(path.sep) ? realRoot : realRoot + path.sep;
+        if (real !== realRoot && !real.startsWith(prefix))
+            throw new Error("Resolved path escapes PROJECT_ROOT.");
+        return real;
+    }
+    async fileHash(relativePath) {
+        return sha256(await fs.readFile(await this.existing(relativePath)));
+    }
+    applyOne(text, edits) {
+        const normalized = edits.map((edit) => {
+            const start = edit.startOffset ?? (edit.startLine && edit.startColumn ? offsetAt(text, edit.startLine, edit.startColumn) : NaN);
+            const end = edit.endOffset ?? (edit.endLine && edit.endColumn ? offsetAt(text, edit.endLine, edit.endColumn) : start);
+            if (!Number.isFinite(start) || !Number.isFinite(end) || start < 0 || end < start || end > text.length)
+                throw new Error("Invalid edit range.");
+            return { start, end, replacement: edit.replacement };
+        }).sort((a, b) => b.start - a.start || b.end - a.end);
+        let previousStart = text.length + 1;
+        for (const edit of normalized) {
+            if (edit.end > previousStart)
+                throw new Error("Overlapping edits are not allowed.");
+            previousStart = edit.start;
+        }
+        let updated = text;
+        for (const edit of normalized)
+            updated = updated.slice(0, edit.start) + edit.replacement + updated.slice(edit.end);
+        return updated;
+    }
+    async applyEdits(files) {
+        if (!files.length)
+            throw new Error("No edits provided.");
+        const prepared = [];
+        const seen = new Set();
+        for (const fileEdit of files) {
+            if (seen.has(fileEdit.path))
+                throw new Error(`Duplicate edit target: ${fileEdit.path}`);
+            seen.add(fileEdit.path);
+            const absolute = await this.existing(fileEdit.path);
+            const original = await fs.readFile(absolute);
+            const originalHash = sha256(original);
+            if (fileEdit.expectedHash && fileEdit.expectedHash !== originalHash)
+                throw new Error(`File changed since read. Expected ${fileEdit.expectedHash}, got ${originalHash}.`);
+            const text = original.toString("utf8");
+            if (text.includes("\u0000"))
+                throw new Error(`Binary file cannot be structurally edited: ${fileEdit.path}`);
+            const updated = Buffer.from(this.applyOne(text, fileEdit.edits), "utf8");
+            prepared.push({
+                relative: fileEdit.path,
+                absolute,
+                original,
+                updated,
+                originalHash,
+                updatedHash: sha256(updated),
+                temp: path.join(path.dirname(absolute), `.${path.basename(absolute)}.${randomUUID()}.codelocal.tmp`),
+                backup: path.join(path.dirname(absolute), `.${path.basename(absolute)}.${randomUUID()}.codelocal.bak`),
+            });
+        }
+        for (const item of prepared) {
+            await fs.writeFile(item.temp, item.updated, { mode: (await fs.stat(item.absolute)).mode });
+        }
+        const committed = [];
+        try {
+            for (const item of prepared) {
+                await fs.rename(item.absolute, item.backup);
+                await fs.rename(item.temp, item.absolute);
+                committed.push(item);
+            }
+            for (const item of committed)
+                await fs.unlink(item.backup).catch(() => undefined);
+        }
+        catch (error) {
+            for (const item of committed.reverse()) {
+                await fs.unlink(item.absolute).catch(() => undefined);
+                await fs.rename(item.backup, item.absolute).catch(() => undefined);
+            }
+            throw error;
+        }
+        finally {
+            for (const item of prepared) {
+                await fs.unlink(item.temp).catch(() => undefined);
+                if (!committed.includes(item))
+                    await fs.unlink(item.backup).catch(() => undefined);
+            }
+        }
+        return {
+            changed: prepared.map((item) => ({ path: item.relative, beforeHash: item.originalHash, afterHash: item.updatedHash, bytes: item.updated.length })),
+            atomicValidation: true,
+            rollbackOnFailure: true,
+        };
+    }
+    async formatChangedFiles(relativePaths) {
+        const paths = [...new Set(relativePaths)].filter(Boolean);
+        if (!paths.length)
+            return { formatted: [], skipped: [] };
+        for (const p of paths)
+            this.lexical(p);
+        const formatted = new Set();
+        const skipped = new Set();
+        const nodeFiles = paths.filter((p) => /\.(js|jsx|ts|tsx|json|css|scss|md|yaml|yml)$/.test(p));
+        if (nodeFiles.length) {
+            const prettier = path.join(this.root, "node_modules", ".bin", process.platform === "win32" ? "prettier.cmd" : "prettier");
+            const biome = path.join(this.root, "node_modules", ".bin", process.platform === "win32" ? "biome.cmd" : "biome");
+            if (await executable(prettier)) {
+                const result = await run(prettier, ["--write", ...nodeFiles], this.root);
+                if (result.code === 0)
+                    nodeFiles.forEach((p) => formatted.add(p));
+                else
+                    nodeFiles.forEach((p) => skipped.add(p));
+            }
+            else if (await executable(biome)) {
+                const result = await run(biome, ["format", "--write", ...nodeFiles], this.root);
+                if (result.code === 0)
+                    nodeFiles.forEach((p) => formatted.add(p));
+                else
+                    nodeFiles.forEach((p) => skipped.add(p));
+            }
+            else
+                nodeFiles.forEach((p) => skipped.add(p));
+        }
+        const groups = [
+            { ext: /\.py$/, command: "ruff", args: (p) => ["format", p] },
+            { ext: /\.rs$/, command: "rustfmt", args: (p) => [p] },
+            { ext: /\.go$/, command: "gofmt", args: (p) => ["-w", p] },
+            { ext: /\.(c|cc|cpp|cxx|h|hpp)$/, command: "clang-format", args: (p) => ["-i", p] },
+        ];
+        for (const group of groups) {
+            const candidates = paths.filter((p) => group.ext.test(p) && !formatted.has(p));
+            if (!candidates.length)
+                continue;
+            const available = await this.findOnPath(group.command);
+            if (!available) {
+                candidates.forEach((p) => skipped.add(p));
+                continue;
+            }
+            for (const p of candidates) {
+                const result = await run(group.command, group.args(p), this.root);
+                if (result.code === 0)
+                    formatted.add(p);
+                else
+                    skipped.add(p);
+            }
+        }
+        return { formatted: [...formatted], skipped: [...skipped] };
+    }
+    async findOnPath(command) {
+        for (const dir of (process.env.PATH ?? "").split(path.delimiter)) {
+            for (const suffix of process.platform === "win32" ? [".exe", ".cmd", ".bat", ""] : [""]) {
+                if (await executable(path.join(dir, `${command}${suffix}`)))
+                    return true;
+            }
+        }
+        return false;
+    }
+}

package/dist/identity.js

@@ -0,0 +1,30 @@
+import os from "node:os";
+import path from "node:path";
+import { unlink } from "node:fs/promises";
+import { DEFAULT_STATE_DIR, readJsonFile, writeJsonAtomic } from "./state.js";
+const CREDENTIAL_FILE = process.env.CODELOCAL_CREDENTIAL_FILE ?? path.join(DEFAULT_STATE_DIR, "device-credential.json");
+export async function loadLocalCredential(serverUrl) {
+    const value = await readJsonFile(CREDENTIAL_FILE, null);
+    if (!value)
+        return null;
+    if (serverUrl && value.serverUrl.replace(/\/$/, "") !== serverUrl.replace(/\/$/, ""))
+        return null;
+    return value;
+}
+export async function saveLocalCredential(value) {
+    const credential = {
+        ...value,
+        createdAt: value.createdAt ?? Date.now(),
+    };
+    await writeJsonAtomic(CREDENTIAL_FILE, credential);
+    return credential;
+}
+export async function deleteLocalCredential() {
+    await unlink(CREDENTIAL_FILE).catch(() => undefined);
+}
+export function defaultDeviceIdentity() {
+    return {
+        deviceId: process.env.CODELOCAL_DEVICE_ID ?? os.hostname(),
+        deviceName: process.env.CODELOCAL_DEVICE_NAME ?? os.hostname(),
+    };
+}