@yagni-app/code-staging 1.0.7-staging.1267.1 → 1.0.7-staging.1270.1

package/dist/extension/settingsFiles.js

@@ -0,0 +1,206 @@
+/**
+ * Shared settings-file plumbing for the three YAGNI Code settings tiers:
+ *   user    ~/.yagni-code/config.json                 (always trusted)
+ *   project .yagni-code/config.json under the cwd    (shared, committed)
+ *   local   .yagni-code/config.local.json under cwd  (personal, gitignored)
+ *
+ * Owns the atomic config mutation (promoted from sandbox/session.ts, the
+ * single copy now) and the global-gitignore helper (Claude Code
+ * addFileGlobRuleToGitignore parity): on the first write to the local file,
+ * the LOCAL_GITIGNORE_ENTRY glob lands in the GLOBAL git ignore file so
+ * personal settings are never committed. Fail-soft by design — a gitignore
+ * failure never fails the settings write.
+ */
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { existsSync, lstatSync, mkdirSync, readFileSync, appendFileSync, writeFileSync, renameSync, chmodSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { logEvent } from "./errorSink.js";
+const LOCAL_GITIGNORE_ENTRY = "**/.yagni-code/config.local.json";
+function isPlainRecord(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+/**
+ * Safe config-file mutation shared by every settings writer:
+ *  - a PARSE FAILURE aborts (never treats a corrupt/half-written file as
+ *    empty — that would wipe activeProfile/permissions);
+ *  - the write is ATOMIC (tmp file + rename) so a crash never truncates;
+ *  - symlinked targets are rejected (a hostile repo's config symlink must
+ *    not redirect writes to arbitrary paths);
+ *  - the mutator runs only on a parsed object; a thrown mutator aborts.
+ * Throws on any failure — callers decide fail-soft messaging.
+ */
+/**
+ * Reject when the target's EXISTING parent directory is a symlink — a
+ * hostile repo can commit a symlinked `.yagni-code` DIRECTORY, and every
+ * local-settings write would then land outside the repo via the symlinked
+ * parent (the final-component lstat guard cannot see this). The parent is
+ * the repo-committable component (`.yagni-code` for project/local targets,
+ * the state home for user targets); ancestors above it are the user's own
+ * filesystem, not repo-controlled. Absent parent is fine — mkdirSync
+ * creates it fresh, and mkdir does not follow a symlinked path segment it
+ * creates itself. Fail closed.
+ */
+function assertRealParentDir(target) {
+    const dir = dirname(target);
+    try {
+        const st = lstatSync(dir);
+        if (!st.isDirectory() || st.isSymbolicLink()) {
+            throw new Error(`${dir} is not a real directory (symlinked parent?) — refusing to write through it`);
+        }
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return; // absent — created fresh below
+        throw err;
+    }
+}
+export function mutateConfigJson(target, mutate) {
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(target, "utf-8"));
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            parsed = {}; // genuinely fresh file — fine
+        }
+        else {
+            throw new Error(`config at ${target} is not valid JSON — refusing to rewrite it`);
+        }
+    }
+    if (!isPlainRecord(parsed))
+        throw new Error(`config at ${target} is not an object`);
+    const config = { ...parsed };
+    mutate(config);
+    mkdirSync(dirname(target), { recursive: true });
+    // Reject symlinked targets: lstat must show a regular file (or absent).
+    try {
+        const st = lstatSync(target);
+        if (!st.isFile())
+            throw new Error(`${target} is not a regular file (symlink?) — refusing`);
+    }
+    catch (err) {
+        if (err.code !== "ENOENT")
+            throw err;
+    }
+    // And a symlinked PARENT directory: a committed symlinked .yagni-code
+    // dir would redirect the write outside the project — the final-component
+    // guard above cannot see it.
+    assertRealParentDir(target);
+    const tmp = `${target}.yagni-tmp-${process.pid}-${randomUUID().slice(0, 8)}`;
+    writeFileSync(tmp, JSON.stringify(config, null, 2) + "\n", { mode: 0o600 });
+    // chmod: writeFile honors mode only on create — guarantee 0600 even when a
+    // same-pid retry reuses an existing tmp file.
+    chmodSync(tmp, 0o600);
+    renameSync(tmp, target);
+}
+/** The project-local settings path for a session cwd. */
+export function localConfigPath(cwd) {
+    return join(cwd, ".yagni-code", "config.local.json");
+}
+/**
+ * Mutate the project-local settings file. Every write fire-and-forgets
+ * ensureLocalGitignored (Claude parity: the local tier is added to the
+ * global git ignore on write, not on session start). The helper is
+ * fire-and-forget BY DESIGN — the write's success notice is not gated on
+ * two git spawns; when the gitignore step is skipped or fails, the sink
+ * warn (gitignore_skipped / gitignore_update_failed) is the designed
+ * signal, surfaced via the diagnostics trail.
+ *
+ * `sinkSource` attributes those sink events to the caller's surface
+ * ("permission-rules" for rule saves, "sandbox" for panel/toggle writes) —
+ * the diagnostics trail then says which surface's write failed to get
+ * ignore-protected, not a blanket permission-rules line for every write.
+ */
+export function mutateLocalConfig(cwd, mutate, sinkSource = "permission-rules") {
+    mutateConfigJson(localConfigPath(cwd), mutate);
+    void ensureLocalGitignored(cwd, process.env, sinkSource);
+}
+// ---------------------------------------------------------------------------
+// Global-gitignore helper (Claude addFileGlobRuleToGitignore parity)
+// ---------------------------------------------------------------------------
+/** Run git <args> in cwd; resolves exit code (never throws). env threads
+ * through so the caller's PATH governs git resolution. */
+function git(cwd, args, env) {
+    return new Promise((resolve) => {
+        try {
+            const child = spawn("git", args, { cwd, env, stdio: "ignore" });
+            child.on("error", () => resolve(GIT_NOT_INSTALLED));
+            child.on("exit", (code) => resolve(code ?? GIT_NOT_INSTALLED));
+        }
+        catch {
+            resolve(GIT_NOT_INSTALLED);
+        }
+    });
+}
+const GIT_NOT_INSTALLED = -1;
+/**
+ * The global git ignore path git actually reads. Git consults
+ * $XDG_CONFIG_HOME/git/ignore (defaulting ~/.config/git/ignore) — honoring
+ * XDG is a deliberate divergence from Claude (which hardcodes ~/.config):
+ * writing a file git will not read when XDG is set would be a silent no-op.
+ */
+export function globalGitignorePath(env = process.env) {
+    const xdg = env.XDG_CONFIG_HOME && env.XDG_CONFIG_HOME.trim() !== "" ? env.XDG_CONFIG_HOME : null;
+    return join(xdg ?? join(homedir(), ".config"), "git", "ignore");
+}
+/**
+ * Ensure the LOCAL_GITIGNORE_ENTRY glob (covering config.local.json at any
+ * depth) is ignored by the user's GLOBAL git config so local settings are
+ * never committed. Skip when:
+ *  - cwd is not inside a git repo (nothing to protect);
+ *  - `git check-ignore` already matches (local or global patterns cover it);
+ *  - the global ignore file already carries the literal entry.
+ * Any failure logs one warn sink event and returns — the settings write it
+ * accompanies has already succeeded and must not be walked back.
+ */
+export async function ensureLocalGitignored(cwd, env = process.env, sinkSource = "permission-rules") {
+    try {
+        const inside = await git(cwd, ["rev-parse", "--is-inside-work-tree"], env);
+        // -1 = git missing or failed to spawn — protection silently skipped; a
+        // warn makes that visible (the file exists un-ignored). 128 = cleanly
+        // not a repo — the documented skip, nothing to surface.
+        if (inside === GIT_NOT_INSTALLED) {
+            logEvent({
+                source: sinkSource,
+                level: "warn",
+                event: "gitignore_skipped",
+                fields: { reason: "git-unavailable" },
+            });
+            return;
+        }
+        // Not inside a repo (128) or a failed rev-parse: skip, nothing to do.
+        if (inside !== 0)
+            return;
+        // 0 = already ignored by some pattern (project .gitignore or global).
+        if ((await git(cwd, ["check-ignore", ".yagni-code/config.local.json"], env)) === 0)
+            return;
+        const path = globalGitignorePath(env);
+        mkdirSync(dirname(path), { recursive: true });
+        if (existsSync(path)) {
+            const content = readFileSync(path, "utf-8");
+            if (content.includes(LOCAL_GITIGNORE_ENTRY))
+                return;
+            appendFileSync(path, `${content.endsWith("\n") ? "" : "\n"}${LOCAL_GITIGNORE_ENTRY}\n`);
+        }
+        else {
+            writeFileSync(path, `${LOCAL_GITIGNORE_ENTRY}\n`, { mode: 0o644 });
+        }
+    }
+    catch (err) {
+        logEvent({
+            source: sinkSource,
+            level: "warn",
+            event: "gitignore_update_failed",
+            fields: {
+                path: globalGitignorePath(env),
+                // The thrown message names the failing operation and the local
+                // filesystem path (mkdir/append of the ignore file) — no secret
+                // surface, and it makes EACCES-vs-ENOSPC diagnosable.
+                error: err instanceof Error ? err.message : String(err),
+            },
+        });
+    }
+}
+//# sourceMappingURL=settingsFiles.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yagni-app/code-staging",
-  "version": "1.0.7-staging.1267.1",
+  "version": "1.0.7-staging.1270.1",
   "description": "YAGNI Code: a terminal coding agent that already knows your company. One YAGNI login routes the model and grounds the agent in your team's context.",
   "license": "SEE LICENSE IN LICENSE.md",
   "author": "YAGNI, Inc. <jack@yagni.app> (https://yagni.app)",
@@ -58,5 +58,5 @@
     "turndown": "^7.2.4",
     "typebox": "^1.3.15"
   },
-  "yagniSourceSha": "594ebbbef9ba1c2233382184dad54d1e81a3bc0f"
+  "yagniSourceSha": "7148d4d0a99f32505ec662e0bbd209279306b4b9"
 }