chamba 0.7.0 → 0.8.0

package/dist/commands/settings.js

@@ -1,349 +1,15 @@
-// =========================================================================================================================================
-// src/commands/settings.ts - Settings submenu: git mode, shadow paths, ports, rebuild, reset config
-// =========================================================================================================================================
-import { spawnSync } from "node:child_process";
-import { relative } from "node:path";
-import { cancel, confirm, isCancel, log, multiselect, note, outro, path, select, text } from "@clack/prompts";
-import { buildDefaultChambaYaml, readChambaYaml, writeChambaYaml } from "../lib/chamba-yaml.js";
-import { GIT_MODE } from "../lib/constants.js";
-import { readWebRange, writeWebRange } from "../lib/global-config.js";
-import { formatWebRange, PORT_MAX, PORT_MIN, parseWebRange } from "../lib/ports.js";
-import { countPatternHits } from "../lib/shadows.js";
-import { readWebKey, reassignOutOfRangeWebPorts, webInterfaceUrl } from "../lib/webterm.js";
-import { readGitMode, readWebPort, writeGitMode } from "../lib/workspace-identity.js";
-// --- Shadow paths menu -------------------------------------------------------------------------------------------------------------------
-async function shadowPathsMenu(ctx) {
-    const yaml = readChambaYaml(ctx.workspaceRoot);
-    if (!yaml) {
-        log.error("chamba.yaml not found or invalid.");
-        return;
-    }
-    const patterns = yaml.shadow_paths ?? [];
-    if (patterns.length > 0) {
-        const lines = patterns.map((p) => {
-            const hits = countPatternHits(p, ctx.workspaceRoot);
-            return `  ${p}  (${hits} ${hits === 1 ? "match" : "matches"})`;
-        });
-        note(lines.join("\n"), "Shadow patterns");
-    }
-    else {
-        log.info("No shadow patterns configured.");
-    }
-    log.message("Shadow patterns block the agent from seeing matching host paths -\n" +
-        "the container gets an empty, isolated copy instead.\n" +
-        "Supports gitignore-style patterns (e.g. node_modules, .env*).\n" +
-        "Git-tracked paths are skipped to avoid worktree diversions.");
-    const options = [{ value: "add", label: "Add pattern or path" }];
-    if (patterns.length > 0) {
-        options.push({ value: "remove", label: "Remove patterns" });
-    }
-    options.push({ value: "back", label: "← Back" });
-    const action = await select({ message: "Shadow paths:", options });
-    if (isCancel(action) || action === "back")
-        return;
-    if (action === "add") {
-        await addShadowPattern(ctx);
-    }
-    else if (action === "remove") {
-        await removeShadowPatterns(ctx);
-    }
-}
-async function addShadowPattern(ctx) {
-    const yaml = readChambaYaml(ctx.workspaceRoot);
-    if (!yaml)
-        return;
-    const patterns = [...(yaml.shadow_paths ?? [])];
-    const typeChoice = await select({
-        message: "Add:",
-        options: [
-            { value: "pattern", label: "Pattern", hint: "gitignore-style (e.g. .env*, *.log)" },
-            { value: "path", label: "Specific path", hint: "pick a file or directory" },
-        ],
-    });
-    if (isCancel(typeChoice))
-        return;
-    if (typeChoice === "pattern") {
-        const input = await text({
-            message: "Pattern:",
-            placeholder: "e.g. .env* or node_modules",
-            validate: (v) => {
-                const p = (v ?? "").trim();
-                if (p.length === 0)
-                    return "Pattern cannot be empty";
-                if (patterns.includes(p))
-                    return "Pattern already exists";
-                return undefined;
-            },
-        });
-        if (isCancel(input))
-            return;
-        const pattern = input.trim();
-        const hits = countPatternHits(pattern, ctx.workspaceRoot);
-        patterns.push(pattern);
-        log.info(`Added: ${pattern} (${hits} ${hits === 1 ? "match" : "matches"})`);
-    }
-    else {
-        const selected = await path({
-            message: "Path to shadow:",
-            root: ctx.workspaceRoot,
-            directory: true,
-        });
-        if (isCancel(selected))
-            return;
-        const absPath = selected.trim();
-        const rel = relative(ctx.workspaceRoot, absPath);
-        if (!rel || rel.startsWith("..")) {
-            log.warn("Path must be inside the workspace directory. Skipped.");
-            return;
-        }
-        if (patterns.includes(rel)) {
-            log.warn(`"${rel}" is already in shadow patterns. Skipped.`);
-            return;
-        }
-        patterns.push(rel);
-        log.info(`Added: ${rel}`);
-    }
-    yaml.shadow_paths = patterns;
-    writeChambaYaml(ctx.workspaceRoot, yaml);
-    await promptStopContainer(ctx);
-}
-async function removeShadowPatterns(ctx) {
-    const yaml = readChambaYaml(ctx.workspaceRoot);
-    if (!yaml?.shadow_paths?.length)
-        return;
-    const toRemove = await multiselect({
-        message: "Select patterns to remove: (space to toggle, enter to confirm)",
-        options: yaml.shadow_paths.map((p) => ({ value: p, label: p })),
-    });
-    if (isCancel(toRemove))
-        return;
-    const removeSet = new Set(toRemove);
-    yaml.shadow_paths = yaml.shadow_paths.filter((p) => !removeSet.has(p));
-    writeChambaYaml(ctx.workspaceRoot, yaml);
-    log.success(`Removed ${removeSet.size} pattern(s).`);
-    await promptStopContainer(ctx);
-}
-// --- Git mode menu -----------------------------------------------------------------------------------------------------------------------
-async function gitModeMenu(ctx) {
-    const current = readGitMode(ctx.workspaceId) ?? GIT_MODE.local;
-    note("Local         - local mutations allowed; remote blocked\n" +
-        "Strict        - read-only; mutations and remote blocked\n" +
-        "Unrestricted  - no chamba-enforced restrictions", "Git mode");
-    const choice = await select({
-        message: "Git mode:",
-        options: [
-            {
-                value: GIT_MODE.local,
-                label: "Local",
-                hint: current === GIT_MODE.local ? "current · default" : "default",
-            },
-            { value: GIT_MODE.strict, label: "Strict", ...(current === GIT_MODE.strict ? { hint: "current" } : {}) },
-            {
-                value: GIT_MODE.unrestricted,
-                label: "Unrestricted",
-                ...(current === GIT_MODE.unrestricted ? { hint: "current" } : {}),
-            },
-        ],
-        initialValue: current,
-    });
-    if (isCancel(choice))
-        return;
-    if (choice === current)
-        return;
-    if (choice === GIT_MODE.unrestricted) {
-        const confirmed = await confirm({
-            message: "Unrestricted mode disables chamba's built-in git restrictions (allows remote push/pull/fetch). Continue?",
-            initialValue: false,
-        });
-        if (isCancel(confirmed) || !confirmed) {
-            log.info("Git mode unchanged.");
-            return;
-        }
-    }
-    writeGitMode(ctx.workspaceId, choice);
-    log.success(`Git mode set to ${choice}.`);
-    await promptStopContainer(ctx);
-}
-// --- Ports menu ---------------------------------------------------------------------------------------------------------------------------
-// The web interface itself has no setting - it comes up with the container and the browser opens on it. What
-// is left to choose is the host port range every workspace draws its sticky port from, so this screen is that
-// one setting plus where this workspace currently lives.
-async function portsMenu(ctx) {
-    const range = readWebRange();
-    const webPort = readWebPort(ctx.workspaceId);
-    // The URL only opens the interface with the key the running server created, so the live one is shown
-    // whenever it can be read. With nothing running there is no key to show, and saying where it comes
-    // from beats printing half a URL.
-    const liveKey = webPort === null ? null : readWebKey(ctx.containerName);
-    const url = webPort === null
-        ? "no port assigned yet"
-        : liveKey !== null
-            ? webInterfaceUrl(webPort, liveKey)
-            : `${webInterfaceUrl(webPort, null)}  (the key comes with the interface when it starts)`;
-    note(`web interface range:  ${formatWebRange(range)}  (all workspaces)\nthis workspace:       ${url}`, "Ports");
-    log.message("The host port range the web interface draws from.\n" +
-        "Each workspace keeps one sticky port from it, so its URL never changes.\n" +
-        "Loopback-only, never reachable off this machine, and the URL carries a key\n" +
-        "that is minted fresh every time the interface starts.\n" +
-        "Ports your own project publishes are set in chamba.yaml, not here.");
-    const input = await text({
-        message: "Port range (START-END):",
-        placeholder: formatWebRange(range),
-        initialValue: formatWebRange(range),
-        validate: (v) => {
-            const raw = (v ?? "").trim();
-            if (!/^\d+-\d+$/.test(raw))
-                return "Use START-END, e.g. 3900-3999";
-            const parsed = parseWebRange(raw);
-            if (!parsed) {
-                const [start = 0, end = 0] = raw.split("-").map(Number);
-                if (start >= end)
-                    return "Start must be below end";
-                return `Ports must be between ${PORT_MIN} and ${PORT_MAX}`;
-            }
-            return undefined;
-        },
-    });
-    if (isCancel(input))
-        return;
-    const newRange = parseWebRange(input.trim());
-    if (!newRange)
-        return; // Validate above guarantees this never fires; keeps the type narrow.
-    if (formatWebRange(newRange) === formatWebRange(range))
-        return;
-    writeWebRange(newRange);
-    // Only assignments now outside the range move; in-range ports stay sticky.
-    const moves = reassignOutOfRangeWebPorts(newRange);
-    for (const m of moves) {
-        log.info(`${m.workspaceId}: port ${m.from} -> ${m.to}`);
-    }
-    log.success(`Port range set to ${formatWebRange(newRange)}.`);
-    await promptStopContainer(ctx);
-}
-// --- Prompt to stop container ------------------------------------------------------------------------------------------------------------
-async function promptStopContainer(ctx) {
-    const containerName = ctx.containerName;
-    const inspect = spawnSync("docker", ["inspect", "--format", "{{.State.Status}}", containerName], {
-        encoding: "utf8",
-        stdio: "pipe",
-    });
-    const containerStatus = inspect.status === 0 ? inspect.stdout.trim() : null;
-    if (containerStatus !== "running") {
-        log.info("Changes will apply on next session.");
-        return;
-    }
-    const shouldStop = await confirm({ message: "Stop the running container so changes apply on next session?" });
-    if (isCancel(shouldStop) || !shouldStop) {
-        log.warn("Container still running with old config - it will be recreated on next session.");
-        return;
-    }
-    log.info("Stopping container...");
-    spawnSync("docker", ["stop", containerName], { stdio: "pipe" });
-    spawnSync("docker", ["rm", containerName], { stdio: "pipe" });
-    log.info("Container removed. Open a new session to apply changes.");
-}
-// --- Reset chamba.yaml -------------------------------------------------------------------------------------------------------------------
-async function resetChambaYaml(ctx) {
-    const yaml = readChambaYaml(ctx.workspaceRoot);
-    if (!yaml) {
-        log.error("chamba.yaml not found or invalid.");
-        return;
-    }
-    note("This will reset chamba.yaml to the minimal default (workspace_id + shadow_paths).\n" +
-        "Your workspace_id is preserved; shadow_paths reset to the defaults (node_modules, .env*).\n" +
-        "Any env, profiles, or ports settings will be removed - re-add them with your editor, which reads the schema the file points at.", "Reset chamba.yaml");
-    const confirmed = await confirm({ message: "Reset chamba.yaml to defaults?" });
-    if (isCancel(confirmed) || !confirmed)
-        return;
-    const freshYaml = buildDefaultChambaYaml(yaml.workspace_id);
-    writeChambaYaml(ctx.workspaceRoot, freshYaml);
-    log.success("chamba.yaml reset to defaults.");
-    await promptStopContainer(ctx);
-}
-// --- Settings submenu --------------------------------------------------------------------------------------------------------------------
-export async function run(ctx) {
-    while (true) {
-        const currentGitMode = readGitMode(ctx.workspaceId) ?? GIT_MODE.local;
-        const options = [
-            { value: "git-mode", label: "Git mode", hint: `current: ${currentGitMode}` },
-            { value: "shadow-paths", label: "Shadow paths", hint: "manage shadow patterns" },
-            { value: "ports", label: "Ports", hint: `web interface range: ${formatWebRange(readWebRange())}` },
-            { value: "rebuild", label: "Rebuild container", hint: "force a fresh image build" },
-            { value: "clean-rebuild", label: "Clean rebuild", hint: "fresh build, no cache" },
-            { value: "reset", label: "Reset config", hint: "restore chamba.yaml to defaults" },
-            { value: "back", label: "← Back" },
-        ];
-        const action = await select({ message: "Settings:", options });
-        if (isCancel(action) || action === "back") {
-            return "back";
-        }
-        switch (action) {
-            case "git-mode":
-                await gitModeMenu(ctx);
-                break;
-            case "shadow-paths":
-                await shadowPathsMenu(ctx);
-                break;
-            case "ports":
-                await portsMenu(ctx);
-                break;
-            case "rebuild":
-                return "rebuild";
-            case "clean-rebuild":
-                return "clean-rebuild";
-            case "reset":
-                await resetChambaYaml(ctx);
-                break;
-        }
-    }
-}
-// --- Stop workspace container ------------------------------------------------------------------------------------------------------------
-export async function stop(containerName) {
-    const inspectResult = spawnSync("docker", ["inspect", "--type", "container", containerName], { encoding: "utf8" });
-    if (inspectResult.status !== 0) {
-        log.info(`Container ${containerName} is not running.`);
-        return;
-    }
-    const confirmed = await confirm({ message: `Stop ${containerName}?` });
-    if (isCancel(confirmed) || !confirmed) {
-        cancel();
-        return;
-    }
-    log.info(`Stopping ${containerName}...`);
-    // Stop-only (no rm) so the next session resumes fast via the "exited" -> docker start path.
-    spawnSync("docker", ["stop", containerName], { stdio: "pipe" });
-    outro(`${containerName} stopped.`);
-}
-// --- Reset workspace image (stop container + remove image for fresh rebuild) -------------------------------------------------------------
-// Returns false when the user declines a running-container rebuild, so the caller can skip the fresh build
-// and leave the live session untouched.
-export async function resetImage(containerName) {
-    const statusResult = spawnSync("docker", ["inspect", "--type", "container", "--format", "{{.State.Status}}", containerName], {
-        encoding: "utf8",
-        stdio: "pipe",
-    });
-    const containerExists = statusResult.status === 0;
-    const running = containerExists && statusResult.stdout.trim() === "running";
-    // A running container is a live session. A rebuild stops and removes it first, so confirm before
-    // killing it out from under the user rather than surprising them mid-session.
-    if (running) {
-        log.warn("Rebuilding stops and removes the running container.\nAgent memory, settings, and workspace data are preserved.");
-        const proceed = await confirm({ message: "Rebuild now?", initialValue: true });
-        if (isCancel(proceed) || !proceed) {
-            cancel("Rebuild cancelled - container left running.");
-            return false;
-        }
-    }
-    if (containerExists) {
-        log.info(`Stopping container ${containerName}...`);
-        spawnSync("docker", ["stop", containerName], { stdio: "pipe" });
-        spawnSync("docker", ["rm", containerName], { stdio: "pipe" });
-    }
-    const imageResult = spawnSync("docker", ["images", "-q", containerName], { encoding: "utf8", stdio: "pipe" });
-    if ((imageResult.stdout ?? "").trim().length > 0) {
-        log.info(`Removing image ${containerName}...`);
-        spawnSync("docker", ["rmi", containerName], { stdio: "pipe" });
-    }
-    log.info("Image removed - starting fresh build…");
-    return true;
-}
+import{spawnSync as l}from"node:child_process";import{relative as I}from"node:path";import{cancel as v,confirm as h,isCancel as c,log as n,multiselect as A,note as w,outro as T,path as W,select as g,text as R}from"@clack/prompts";import{buildDefaultChambaYaml as U,readChambaYaml as b,writeChambaYaml as y}from"../lib/chamba-yaml.js";import{GIT_MODE as d}from"../lib/constants.js";import{readWebRange as S,writeWebRange as O}from"../lib/global-config.js";import{formatWebRange as p,PORT_MAX as Y,PORT_MIN as E,parseWebRange as $}from"../lib/ports.js";import{countPatternHits as P}from"../lib/shadows.js";import{readWebKey as L,reassignOutOfRangeWebPorts as D,webInterfaceUrl as _}from"../lib/webterm.js";import{readGitMode as C,readWebPort as V,writeGitMode as j}from"../lib/workspace-identity.js";async function B(e){const a=b(e.workspaceRoot);if(!a){n.error("chamba.yaml not found or invalid.");return}const t=a.shadow_paths??[];if(t.length>0){const i=t.map(r=>{const m=P(r,e.workspaceRoot);return`  ${r}  (${m} ${m===1?"match":"matches"})`});w(i.join(`
+`),"Shadow patterns")}else n.info("No shadow patterns configured.");n.message(`Shadow patterns block the agent from seeing matching host paths -
+the container gets an empty, isolated copy instead.
+Supports gitignore-style patterns (e.g. node_modules, .env*).
+Git-tracked paths are skipped to avoid worktree diversions.`);const o=[{value:"add",label:"Add pattern or path"}];t.length>0&&o.push({value:"remove",label:"Remove patterns"}),o.push({value:"back",label:"\u2190 Back"});const s=await g({message:"Shadow paths:",options:o});c(s)||s==="back"||(s==="add"?await K(e):s==="remove"&&await q(e))}async function K(e){const a=b(e.workspaceRoot);if(!a)return;const t=[...a.shadow_paths??[]],o=await g({message:"Add:",options:[{value:"pattern",label:"Pattern",hint:"gitignore-style (e.g. .env*, *.log)"},{value:"path",label:"Specific path",hint:"pick a file or directory"}]});if(!c(o)){if(o==="pattern"){const s=await R({message:"Pattern:",placeholder:"e.g. .env* or node_modules",validate:m=>{const u=(m??"").trim();if(u.length===0)return"Pattern cannot be empty";if(t.includes(u))return"Pattern already exists"}});if(c(s))return;const i=s.trim(),r=P(i,e.workspaceRoot);t.push(i),n.info(`Added: ${i} (${r} ${r===1?"match":"matches"})`)}else{const s=await W({message:"Path to shadow:",root:e.workspaceRoot,directory:!0});if(c(s))return;const i=s.trim(),r=I(e.workspaceRoot,i);if(!r||r.startsWith("..")){n.warn("Path must be inside the workspace directory. Skipped.");return}if(t.includes(r)){n.warn(`"${r}" is already in shadow patterns. Skipped.`);return}t.push(r),n.info(`Added: ${r}`)}a.shadow_paths=t,y(e.workspaceRoot,a),await f(e)}}async function q(e){const a=b(e.workspaceRoot);if(!a?.shadow_paths?.length)return;const t=await A({message:"Select patterns to remove: (space to toggle, enter to confirm)",options:a.shadow_paths.map(s=>({value:s,label:s}))});if(c(t))return;const o=new Set(t);a.shadow_paths=a.shadow_paths.filter(s=>!o.has(s)),y(e.workspaceRoot,a),n.success(`Removed ${o.size} pattern(s).`),await f(e)}async function z(e){const a=C(e.workspaceId)??d.local;w(`Local         - local mutations allowed; remote blocked
+Strict        - read-only; mutations and remote blocked
+Unrestricted  - no chamba-enforced restrictions`,"Git mode");const t=await g({message:"Git mode:",options:[{value:d.local,label:"Local",hint:a===d.local?"current \xB7 default":"default"},{value:d.strict,label:"Strict",...a===d.strict?{hint:"current"}:{}},{value:d.unrestricted,label:"Unrestricted",...a===d.unrestricted?{hint:"current"}:{}}],initialValue:a});if(!c(t)&&t!==a){if(t===d.unrestricted){const o=await h({message:"Unrestricted mode disables chamba's built-in git restrictions (allows remote push/pull/fetch). Continue?",initialValue:!1});if(c(o)||!o){n.info("Git mode unchanged.");return}}j(e.workspaceId,t),n.success(`Git mode set to ${t}.`),await f(e)}}async function H(e){const a=S(),t=V(e.workspaceId),o=t===null?null:L(e.containerName),s=t===null?"no port assigned yet":o!==null?_(t,o):`${_(t,null)}  (the key comes with the interface when it starts)`;w(`web interface range:  ${p(a)}  (all workspaces)
+this workspace:       ${s}`,"Ports"),n.message(`The host port range the web interface draws from.
+Each workspace keeps one sticky port from it, so its URL never changes.
+Loopback-only, never reachable off this machine, and the URL carries a key
+that is minted fresh every time the interface starts.
+Ports your own project publishes are set in chamba.yaml, not here.`);const i=await R({message:"Port range (START-END):",placeholder:p(a),initialValue:p(a),validate:u=>{const k=(u??"").trim();if(!/^\d+-\d+$/.test(k))return"Use START-END, e.g. 3900-3999";if(!$(k)){const[G=0,M=0]=k.split("-").map(Number);return G>=M?"Start must be below end":`Ports must be between ${E} and ${Y}`}}});if(c(i))return;const r=$(i.trim());if(!r||p(r)===p(a))return;O(r);const m=D(r);for(const u of m)n.info(`${u.workspaceId}: port ${u.from} -> ${u.to}`);n.success(`Port range set to ${p(r)}.`),await f(e)}async function f(e){const a=e.containerName,t=l("docker",["inspect","--format","{{.State.Status}}",a],{encoding:"utf8",stdio:"pipe"});if((t.status===0?t.stdout.trim():null)!=="running"){n.info("Changes will apply on next session.");return}const s=await h({message:"Stop the running container so changes apply on next session?"});if(c(s)||!s){n.warn("Container still running with old config - it will be recreated on next session.");return}n.info("Stopping container..."),l("docker",["stop",a],{stdio:"pipe"}),l("docker",["rm",a],{stdio:"pipe"}),n.info("Container removed. Open a new session to apply changes.")}async function X(e){const a=b(e.workspaceRoot);if(!a){n.error("chamba.yaml not found or invalid.");return}w(`This will reset chamba.yaml to the minimal default (workspace_id + shadow_paths).
+Your workspace_id is preserved; shadow_paths reset to the defaults (node_modules, .env*).
+Any env, profiles, or ports settings will be removed - re-add them with your editor, which reads the schema the file points at.`,"Reset chamba.yaml");const t=await h({message:"Reset chamba.yaml to defaults?"});if(c(t)||!t)return;const o=U(a.workspace_id);y(e.workspaceRoot,o),n.success("chamba.yaml reset to defaults."),await f(e)}async function se(e){for(;;){const t=[{value:"git-mode",label:"Git mode",hint:`current: ${C(e.workspaceId)??d.local}`},{value:"shadow-paths",label:"Shadow paths",hint:"manage shadow patterns"},{value:"ports",label:"Ports",hint:`web interface range: ${p(S())}`},{value:"rebuild",label:"Rebuild container",hint:"force a fresh image build"},{value:"clean-rebuild",label:"Clean rebuild",hint:"fresh build, no cache"},{value:"reset",label:"Reset config",hint:"restore chamba.yaml to defaults"},{value:"back",label:"\u2190 Back"}],o=await g({message:"Settings:",options:t});if(c(o)||o==="back")return"back";switch(o){case"git-mode":await z(e);break;case"shadow-paths":await B(e);break;case"ports":await H(e);break;case"rebuild":return"rebuild";case"clean-rebuild":return"clean-rebuild";case"reset":await X(e);break}}}async function re(e){if(l("docker",["inspect","--type","container",e],{encoding:"utf8"}).status!==0){n.info(`Container ${e} is not running.`);return}const t=await h({message:`Stop ${e}?`});if(c(t)||!t){v();return}n.info(`Stopping ${e}...`),l("docker",["stop",e],{stdio:"pipe"}),T(`${e} stopped.`)}async function ie(e){const a=l("docker",["inspect","--type","container","--format","{{.State.Status}}",e],{encoding:"utf8",stdio:"pipe"}),t=a.status===0;if(t&&a.stdout.trim()==="running"){n.warn(`Rebuilding stops and removes the running container.
+Agent memory, settings, and workspace data are preserved.`);const i=await h({message:"Rebuild now?",initialValue:!0});if(c(i)||!i)return v("Rebuild cancelled - container left running."),!1}return t&&(n.info(`Stopping container ${e}...`),l("docker",["stop",e],{stdio:"pipe"}),l("docker",["rm",e],{stdio:"pipe"})),(l("docker",["images","-q",e],{encoding:"utf8",stdio:"pipe"}).stdout??"").trim().length>0&&(n.info(`Removing image ${e}...`),l("docker",["rmi",e],{stdio:"pipe"})),n.info("Image removed - starting fresh build\u2026"),!0}export{ie as resetImage,se as run,re as stop};

package/dist/lib/agent-commands.js

@@ -0,0 +1,2 @@
+import{existsSync as a,readdirSync as p}from"node:fs";import{join as r}from"node:path";import{TOOL_COMMAND_SKILLS as l,TOOL_COMMANDS as h}from"../../templates/webterm/tools/commands.js";import{AGENTS_DIR as u}from"./constants.js";import{safeRmSync as S}from"./safe-rm.js";import{writeFileEnsuringDir as O}from"./templates.js";function w(t){return r(t,u,"opencode","config","commands")}function g(t){const o=w(t),i=new Set;for(const[e,m]of Object.entries(h))for(const[f,d]of Object.entries(m)){const s=d.opencode,n=l[e]?.[f];if(!s?.startsWith("/")||!n)continue;const c=`${s.slice(1)}.md`;i.add(c),O(r(o,c),["---",`description: Start the ${n} skill, which drives a tab of the web pane.`,"---","",`Load the \`${n}\` skill from your skills directory, and follow it.`,"","What the user typed after the command, which may be nothing:","","$ARGUMENTS",""].join(`
+`))}if(a(o))for(const e of p(o))i.has(e)||S(r(o,e),{recursive:!0,force:!0})}export{g as injectOpencodeCommands,w as opencodeCommandsDir};

package/dist/lib/agent-context.js

@@ -1,210 +1,6 @@
-// Agent mount definitions and context injection for AI CLIs running inside chamba containers.
-//
-// This file is the single source of truth for which directories each AI CLI reads/writes
-// and how chamba intercepts them via bind mounts. If an AI CLI changes its config layout,
-// this file must be updated.
-//
-// Verify against official docs periodically:
-//   Claude Code: https://docs.anthropic.com/en/docs/claude-code
-//   OpenCode:    https://github.com/opencode-ai/opencode
-//   Codex:       https://github.com/openai/codex
-import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { AGENTS_DIR, CLAUDE_STATUSLINE_PATH, CONTAINER_HOME, GIT_MODE, PACKAGE_ROOT } from "./constants.js";
-export const AGENT_MOUNTS = [
-    {
-        agent: "claude",
-        hostSubpath: "claude",
-        container: `${CONTAINER_HOME}/.claude`,
-        description: "Claude Code user-level config and session data",
-    },
-    {
-        agent: "opencode",
-        hostSubpath: "opencode/config",
-        container: `${CONTAINER_HOME}/.config/opencode`,
-        description: "OpenCode user-level config",
-    },
-    {
-        agent: "opencode",
-        hostSubpath: "opencode/data",
-        container: `${CONTAINER_HOME}/.local/share/opencode`,
-        description: "OpenCode user-level data and session history",
-    },
-    {
-        agent: "codex",
-        hostSubpath: "codex",
-        container: `${CONTAINER_HOME}/.codex`,
-        description: "Codex user-level config and session data",
-    },
-];
-export const AGENT_FILE_MOUNTS = [
-    {
-        // .claude.json lives outside ~/.claude/ so it is not covered by the directory mount.
-        // Persisting it as a file mount avoids losing Claude Code settings on container rebuild.
-        hostSubpath: "claude/.claude.json",
-        container: `${CONTAINER_HOME}/.claude.json`,
-        initialContent: "{}\n",
-    },
-];
-// --- Build agent mount args --------------------------------------------------------------------------------------------------------------
-/**
- * Creates agents/ subdirectories in the workspace cache dir on the host (lazily) and
- * returns volume mount args for all supported agent tools.
- */
-export function buildAgentMountArgs(workspaceDir) {
-    const agentsDir = join(workspaceDir, AGENTS_DIR);
-    const mounts = AGENT_MOUNTS.map((m) => ({
-        host: join(agentsDir, m.hostSubpath),
-        container: m.container,
-    }));
-    for (const { host } of mounts)
-        mkdirSync(host, { recursive: true });
-    const fileMounts = AGENT_FILE_MOUNTS.map((m) => ({
-        host: join(agentsDir, m.hostSubpath),
-        container: m.container,
-        initialContent: m.initialContent,
-    }));
-    for (const { host, initialContent } of fileMounts) {
-        if (!existsSync(host))
-            writeFileSync(host, initialContent);
-    }
-    return [
-        ...mounts.flatMap(({ host, container }) => ["-v", `${host}:${container}`]),
-        ...fileMounts.flatMap(({ host, container }) => ["-v", `${host}:${container}`]),
-    ];
-}
-// --- Template helpers --------------------------------------------------------------------------------------------------------------------
-function loadTemplate(name) {
-    return readFileSync(join(PACKAGE_ROOT, "templates", "context", `${name}.md`), "utf8").trimEnd();
-}
-function renderTemplate(template, vars) {
-    return template.replace(/\{\{(\w+)\}\}/g, (_, key) => vars[key] ?? `{{${key}}}`);
-}
-function writeFileEnsuringDir(filePath, content) {
-    mkdirSync(dirname(filePath), { recursive: true });
-    writeFileSync(filePath, content);
-}
-// --- Build agent context documents -------------------------------------------------------------------------------------------------------
-/**
- * Assembles the agent context markdown injected into each supported agent's config dir at session start.
- */
-export function buildAgentContextDocs(hasGit, shadowPatterns, gitMode = GIT_MODE.local) {
-    const gitSection = loadTemplate(hasGit ? `git-mode-${gitMode}` : "git-unavailable");
-    const shadowSection = shadowPatterns && shadowPatterns.length > 0
-        ? renderTemplate(loadTemplate("shadow-paths"), {
-            // Indented two spaces to nest under the section's leading bullet.
-            pattern_list: shadowPatterns.map((p) => `  - \`${p}\``).join("\n"),
-        })
-        : null;
-    const baselineTemplate = loadTemplate("baseline");
-    // The doc is one bullet list: baseline holds the unconditional bullets, followed by the
-    // conditional ones (shadow paths, git mode) and any agent-specific extras.
-    function build(toolPath, extraSections = []) {
-        const sections = [
-            renderTemplate(baselineTemplate, { tool_path: toolPath }),
-            ...(shadowSection ? [shadowSection] : []),
-            gitSection,
-            ...extraSections,
-        ];
-        return `${sections.join("\n")}\n`;
-    }
-    // The page-writing craft is claude's web-pane skill body, and this is the same file: a skill is a Claude
-    // Code mechanism, so an AGENTS.md section is the only channel codex and opencode have for it. Claude does
-    // not get it here - it reads it as the skill, and a second copy in its CLAUDE.md would say it twice.
-    // The leading newline: the sections above are one bullet list, and this one opens with a heading.
-    const craftSection = `\n${loadTemplate("web-pane-craft")}`;
-    // The context-usage section is Claude-only: the snapshot it points at is written by the status line
-    // script Claude Code runs, so other agents' sessions never refresh it.
-    return {
-        claude: build("~/.claude/CLAUDE.md", [loadTemplate("context-usage")]),
-        opencode: build("~/.config/opencode/AGENTS.md", [craftSection]),
-        codex: build("~/.codex/AGENTS.md", [craftSection]),
-    };
-}
-// --- Claude settings.json bootstrap ------------------------------------------------------------------------------------------------------
-function readSettingsObject(path) {
-    try {
-        const parsed = JSON.parse(readFileSync(path, "utf8"));
-        if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
-            return parsed;
-        }
-    }
-    catch {
-        // Missing file or malformed JSON: caller proceeds with an empty object.
-    }
-    return {};
-}
-// Sets ~/.claude/settings.json -> statusLine to the chamba default if no value is set.
-// Non-destructive: preserves other fields and never overwrites a user-set statusLine.
-export function ensureClaudeStatusLine(workspaceDir) {
-    const settingsPath = join(workspaceDir, AGENTS_DIR, "claude", "settings.json");
-    const settings = readSettingsObject(settingsPath);
-    if (settings.statusLine === undefined) {
-        settings.statusLine = { type: "command", command: CLAUDE_STATUSLINE_PATH };
-        writeFileEnsuringDir(settingsPath, `${JSON.stringify(settings, null, 2)}\n`);
-    }
-}
-// --- Claude skills injection -------------------------------------------------------------------------------------------------------------
-// Copies every templates/skills/<name>/ into agents/claude/skills/<name>/, whole. Drop a new directory
-// under templates/skills/ to ship a new skill - no other code changes needed.
-//
-// The directory rather than the one file, because a skill of any size keeps its craft in references/ and
-// points at those files by name. A SKILL.md that reaches a session without them names files that are not
-// there, which is worse than shipping nothing.
-export function injectClaudeSkills(workspaceDir) {
-    const templatesSkillsDir = join(PACKAGE_ROOT, "templates", "skills");
-    if (!existsSync(templatesSkillsDir))
-        return;
-    const targetSkillsDir = join(workspaceDir, AGENTS_DIR, "claude", "skills");
-    // web_pane_craft is the page-writing advice codex and opencode also get, as a section of their AGENTS.md.
-    // One file, rendered into both channels, so the two cannot come to say different things.
-    const vars = { statusline_path: CLAUDE_STATUSLINE_PATH, web_pane_craft: loadTemplate("web-pane-craft") };
-    for (const entry of readdirSync(templatesSkillsDir, { withFileTypes: true })) {
-        if (!entry.isDirectory())
-            continue;
-        if (!existsSync(join(templatesSkillsDir, entry.name, "SKILL.md")))
-            continue;
-        copySkillDir(join(templatesSkillsDir, entry.name), join(targetSkillsDir, entry.name), vars);
-    }
-}
-// One skill's files, at whatever depth they sit. Markdown is rendered with the skill variables, since a
-// reference states the same placeholders SKILL.md does; anything else is copied byte for byte.
-function copySkillDir(from, to, vars) {
-    for (const entry of readdirSync(from, { withFileTypes: true })) {
-        const source = join(from, entry.name);
-        const target = join(to, entry.name);
-        // A link is copied as what it points at. The container gets a directory rather than a tree of links,
-        // and a shared reference brought in as a link still ships - a skill naming a file this walk skipped
-        // is exactly the broken skill that copying the whole directory exists to prevent.
-        const kind = statSync(source);
-        if (kind.isDirectory()) {
-            copySkillDir(source, target, vars);
-        }
-        else if (kind.isFile()) {
-            if (entry.name.endsWith(".md")) {
-                writeFileEnsuringDir(target, renderTemplate(readFileSync(source, "utf8"), vars));
-            }
-            else {
-                mkdirSync(dirname(target), { recursive: true });
-                copyFileSync(source, target);
-            }
-        }
-    }
-}
-// --- Inject agent context ----------------------------------------------------------------------------------------------------------------
-/**
- * Writes agent context markdown files into the workspace's agents/ directory.
- */
-export function injectAgentContext(workspaceDir, docs) {
-    const a = join(workspaceDir, AGENTS_DIR);
-    const files = [
-        { path: join(a, "claude", "CLAUDE.md"), content: docs.claude },
-        { path: join(a, "opencode", "config", "AGENTS.md"), content: docs.opencode },
-        { path: join(a, "codex", "AGENTS.md"), content: docs.codex },
-    ];
-    for (const { path: filePath, content } of files) {
-        writeFileEnsuringDir(filePath, content);
-    }
-    ensureClaudeStatusLine(workspaceDir);
-    injectClaudeSkills(workspaceDir);
-}
+import{existsSync as h,mkdirSync as g,readFileSync as S,writeFileSync as b}from"node:fs";import{join as i}from"node:path";import{injectOpencodeCommands as A}from"./agent-commands.js";import{AGENTS_DIR as l,CLAUDE_STATUSLINE_PATH as u,CONTAINER_HOME as a,GIT_MODE as C}from"./constants.js";import{injectSkills as T}from"./skills.js";import{loadTemplate as d,renderTemplate as f,writeFileEnsuringDir as m}from"./templates.js";const x=[{agent:"claude",hostSubpath:"claude",container:`${a}/.claude`,description:"Claude Code user-level config and session data"},{agent:"opencode",hostSubpath:"opencode/config",container:`${a}/.config/opencode`,description:"OpenCode user-level config"},{agent:"opencode",hostSubpath:"opencode/config/commands",container:`${a}/.config/opencode/commands`,description:"The pane tools' commands chamba ships to OpenCode",readOnly:!0},{agent:"opencode",hostSubpath:"opencode/config/command",container:`${a}/.config/opencode/command`,description:"Held empty, so no command word is defined behind the ones chamba ships",readOnly:!0},{agent:"opencode",hostSubpath:"opencode/data",container:`${a}/.local/share/opencode`,description:"OpenCode user-level data and session history"},{agent:"codex",hostSubpath:"codex",container:`${a}/.codex`,description:"Codex user-level config and session data"}],E=[{hostSubpath:"claude/.claude.json",container:`${a}/.claude.json`,initialContent:`{}
+`}];function M(t){const e=i(t,l),o=x.map(n=>({host:i(e,n.hostSubpath),container:n.readOnly===!0?`${n.container}:ro`:n.container}));for(const{host:n}of o)g(n,{recursive:!0});const s=E.map(n=>({host:i(e,n.hostSubpath),container:n.container,initialContent:n.initialContent}));for(const{host:n,initialContent:c}of s)h(n)||b(n,c);return[...o.flatMap(({host:n,container:c})=>["-v",`${n}:${c}`]),...s.flatMap(({host:n,container:c})=>["-v",`${n}:${c}`])]}function U(t,e,o=C.local){const s=d(t?`git-mode-${o}`:"git-unavailable"),n=e&&e.length>0?f(d("shadow-paths"),{pattern_list:e.map(p=>`  - \`${p}\``).join(`
+`)}):null,c=d("baseline");function r(p){return`${[f(c,{tool_path:p}),...n?[n]:[],s].join(`
+`)}
+`}return{claude:r("~/.claude/CLAUDE.md"),opencode:r("~/.config/opencode/AGENTS.md"),codex:r("~/.codex/AGENTS.md")}}function $(t){try{const e=JSON.parse(S(t,"utf8"));if(e!==null&&typeof e=="object"&&!Array.isArray(e))return e}catch{}return{}}function y(t){const e=i(t,l,"claude","settings.json"),o=$(e);o.statusLine===void 0&&(o.statusLine={type:"command",command:u},m(e,`${JSON.stringify(o,null,2)}
+`))}function D(t,e){const o=i(t,l),s=[{path:i(o,"claude","CLAUDE.md"),content:e.claude},{path:i(o,"opencode","config","AGENTS.md"),content:e.opencode},{path:i(o,"codex","AGENTS.md"),content:e.codex}];for(const{path:n,content:c}of s)m(n,c);y(t),A(t),T(t,{statusline_path:u,web_pane_craft:d("web-pane-craft")})}export{E as AGENT_FILE_MOUNTS,x as AGENT_MOUNTS,U as buildAgentContextDocs,M as buildAgentMountArgs,y as ensureClaudeStatusLine,D as injectAgentContext};

package/dist/lib/browser.js

@@ -1,40 +1 @@
-// =========================================================================================================================================
-// src/lib/browser.ts - Open a URL in the host's default browser
-// One tiny best-effort step of the session start: chamba resolves the web port, brings the interface up,
-// and hands the URL to whatever the platform uses to open links. Never blocks and never fails a session.
-// =========================================================================================================================================
-import { spawnSync } from "node:child_process";
-// A hung opener would sit in front of the user's shell, so give it a short deadline and move on. Every
-// opener below hands the URL to a running desktop and returns at once, so this only bites when something
-// is wrong - and then printing the URL is the better outcome anyway.
-const OPEN_TIMEOUT_MS = 3000;
-/**
- * The argv that opens a URL in the default browser on this platform, or null when we know of no opener for
- * it. Argv, never a shell string: the URL carries a key read back from a file every process in the
- * container can write, so it must reach the opener as one argument and never as something a shell parses.
- * On Windows the opener is `start`, which is a cmd builtin rather than a program, hence the `cmd /c` -
- * its first quoted argument is the window title, which is why an empty one goes before the URL.
- */
-export function browserOpenArgv(url, platform = process.platform) {
-    if (platform === "darwin")
-        return ["open", url];
-    if (platform === "win32")
-        return ["cmd", "/c", "start", "", url];
-    if (platform === "linux")
-        return ["xdg-open", url];
-    return null;
-}
-/**
- * Open a URL in the host's default browser. Returns false when there is no opener for this platform, the
- * opener is not installed (a headless host, an SSH session), or it failed - the caller then prints the URL
- * and carries on. Nothing here is allowed to throw: opening the browser for the user is the convenience, and
- * the printed URL reaches the same interface, so a session must start either way.
- */
-export function openInBrowser(url, platform = process.platform) {
-    const argv = browserOpenArgv(url, platform);
-    if (argv === null)
-        return false;
-    const [command = "", ...args] = argv;
-    const result = spawnSync(command, args, { stdio: "ignore", timeout: OPEN_TIMEOUT_MS });
-    return result.error === undefined && result.status === 0;
-}
+import{spawnSync as i}from"node:child_process";const u=3e3;function c(n,r=process.platform){return r==="darwin"?["open",n]:r==="win32"?["cmd","/c","start","",n]:r==="linux"?["xdg-open",n]:null}function f(n,r=process.platform){const e=c(n,r);if(e===null)return!1;const[o="",...s]=e,t=i(o,s,{stdio:"ignore",timeout:u});return t.error===void 0&&t.status===0}export{c as browserOpenArgv,f as openInBrowser};