@chibitek/chibi 0.1.171 → 0.1.173

package/dist-server/server/workspace-restore-paths.js

@@ -0,0 +1,186 @@
+// Moving a workspace to another computer: the person's home folder, user
+// name and data folder can all differ there. Every absolute path the backup
+// recorded is rebased by an explicit old-root prefix, never by free-form text
+// search, and whatever still points nowhere on this computer is reported.
+import { execFileSync } from "node:child_process";
+import { existsSync, lstatSync, readFileSync, readdirSync, renameSync, symlinkSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join, posix, relative, resolve, win32 } from "node:path";
+export function validRelative(path) {
+    return !!path && path.length <= 4096 && !isAbsolute(path) && !/[\\\0:]/.test(path) &&
+        path.split("/").every((part) => !!part && part !== "." && part !== ".." && !/[. ]$/.test(part) &&
+            !/^(con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i.test(part));
+}
+export function absolutePath(value) {
+    return posix.isAbsolute(value) || win32.isAbsolute(value);
+}
+/** Pairs for a restore: data folder first, then the home folder, skipping
+ * no-op pairs and a source home that is a filesystem root. */
+export function restorePathPairs(source, target) {
+    const pairs = [[source.dataDir, target.dataDir]];
+    if (source.home && source.home.replaceAll("\\", "/").replace(/\/$/, "").includes("/"))
+        pairs.push([source.home, target.home]);
+    return pairs.filter(([from, to]) => from !== to);
+}
+export function rebasePath(value, pairs) {
+    // Normalize Windows separators without interpreting unrelated external paths.
+    const normalized = value.replaceAll("\\", "/");
+    for (const [source, destination] of pairs) {
+        const original = source.replaceAll("\\", "/").replace(/\/$/, "");
+        if (!original || (normalized !== original && !normalized.startsWith(`${original}/`)))
+            continue;
+        const suffix = normalized.slice(original.length).replace(/^\//, "");
+        if (suffix && !validRelative(suffix))
+            return value;
+        return suffix ? join(destination, suffix) : destination;
+    }
+    return value;
+}
+const PATH_KEYS = new Set(["cwd", "pinnedCwd", "workspace", "configDir", "profileDirectory", "agentDir", "dataDir", "home", "cli", "path", "filePath", "localPath"]);
+/** Rebase every known path field in place. With `unresolved`, an absolute
+ * path that `exists` cannot find after rebasing is collected for the report. */
+export function rebaseFields(value, pairs, unresolved) {
+    if (Array.isArray(value)) {
+        for (const item of value)
+            rebaseFields(item, pairs, unresolved);
+        return;
+    }
+    if (!value || typeof value !== "object")
+        return;
+    const fields = value;
+    for (const [key, item] of Object.entries(fields)) {
+        if (PATH_KEYS.has(key) && typeof item === "string") {
+            fields[key] = rebasePath(item, pairs);
+            const next = fields[key];
+            if (unresolved && absolutePath(next) && !unresolved.exists(next))
+                unresolved.paths.add(next);
+        }
+        else if (item && typeof item === "object")
+            rebaseFields(item, pairs, unresolved);
+    }
+}
+/** Notes, SOUL.md, memory and skills mention folders as `<old home>/...`.
+ * Only that exact prefix followed by a separator is rewritten, in one pass so
+ * a new root that contains an old one is never rewritten twice. */
+export function rebaseText(text, pairs) {
+    const roots = new Map(pairs.map(([from, to]) => [`${from.replace(/[\\/]$/, "")}/`, `${to.replace(/[\\/]$/, "")}/`])
+        .filter(([from]) => from.length > 2));
+    if (!roots.size)
+        return text;
+    const pattern = new RegExp([...roots.keys()].sort((a, b) => b.length - a.length).map((root) => root.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|"), "g");
+    return text.replace(pattern, (root) => roots.get(root));
+}
+const TEXT_FILE = /\.(?:md|json|toml)$/;
+const MAX_REWRITE_BYTES = 16 * 1024 ** 2;
+/** Rewrite home-relative paths inside a restored copy: text files under the
+ * bot, skill and provider folders, and the per-folder project directories
+ * Claude Code keeps under a provider home (`.../projects/<encoded path>`).
+ * Project code under task workspaces is the person's own and is left alone. */
+export function rebaseTree(root, pairs) {
+    const visit = (directory, depth) => {
+        for (const name of readdirSync(directory)) {
+            const path = join(directory, name);
+            const stat = lstatSync(path);
+            if (stat.isDirectory()) {
+                if (name === "projects" && relative(root, path).startsWith("providers"))
+                    renameProjectDirs(path, pairs);
+                if (depth < 12)
+                    visit(path, depth + 1);
+            }
+            else if (stat.isFile() && TEXT_FILE.test(name) && stat.size <= MAX_REWRITE_BYTES) {
+                const text = readFileSync(path, "utf8");
+                const next = rebaseText(text, pairs);
+                if (next !== text)
+                    writeFileSync(path, next, { mode: stat.mode & 0o777 });
+            }
+        }
+    };
+    for (const top of ["workspaces", "skills", "providers"])
+        if (existsSync(join(root, top)) && lstatSync(join(root, top)).isDirectory())
+            visit(join(root, top), 0);
+}
+function renameProjectDirs(projects, pairs) {
+    for (const name of readdirSync(projects)) {
+        for (const [from, to] of pairs) {
+            const prefix = encodedProjectDir(from.replace(/[\\/]$/, ""));
+            if (name !== prefix && !name.startsWith(`${prefix}-`))
+                continue;
+            const next = encodedProjectDir(to.replace(/[\\/]$/, "")) + name.slice(prefix.length);
+            if (!existsSync(join(projects, next)))
+                renameSync(join(projects, name), join(projects, next));
+            break;
+        }
+    }
+}
+/** Recreate recorded symbolic links in a restored copy. Absolute targets are
+ * rebased; a relative target may not climb out of the data folder. Links
+ * whose target is missing here are still made, and reported. */
+export function restoreLinks(root, dataDir, links, pairs, unresolved) {
+    const skipped = [];
+    for (const link of links) {
+        const target = absolutePath(link.target) ? rebasePath(link.target, pairs) : link.target;
+        const resolved = absolutePath(target) ? target : resolve(dataDir, dirname(link.path), target);
+        const inside = relative(resolve(dataDir), resolved);
+        const outside = inside === ".." || inside.startsWith("../") || inside.startsWith("..\\") || isAbsolute(inside);
+        if (outside && !absolutePath(target)) {
+            skipped.push(link.path);
+            continue;
+        }
+        // ponytail: plain symlinks; Windows directory links need Developer Mode or a junction.
+        symlinkSync(target, join(root, link.path));
+        if (!existsSync(outside ? resolved : join(root, inside)))
+            unresolved.add(resolved);
+    }
+    return skipped;
+}
+/** The origin a clean, fully pushed checkout can be cloned from again, or
+ * null when anything in it exists only here (changes, unpushed commits, a
+ * branch without upstream, stashes) and it must travel in the backup. */
+export function reclonableCheckout(directory) {
+    const remote = checkoutRemote(directory);
+    if (!remote)
+        return null;
+    try {
+        const git = (...args) => execFileSync("git", ["-C", directory, ...args], { encoding: "utf8", timeout: 30_000, stdio: ["ignore", "pipe", "ignore"] });
+        const lines = git("status", "--porcelain=v1", "--branch").trimEnd().split("\n");
+        if (lines.length !== 1 || !/^## \S+\.\.\.\S+(?: \[behind \d+\])?$/.test(lines[0]))
+            return null;
+        return git("stash", "list").trim() ? null : remote;
+    }
+    catch {
+        return null;
+    }
+}
+/** Claude Code names its per-folder project directories after the folder
+ * path with every non-alphanumeric character turned into "-". */
+export function encodedProjectDir(path) {
+    return path.replace(/[^A-Za-z0-9]/g, "-");
+}
+/** The origin a project checkout can be cloned from again, or null when it
+ * has none and so must travel inside the backup. Worktrees keep `.git` as a
+ * file naming their real git folder; its `commondir` holds the config. */
+export function checkoutRemote(directory) {
+    try {
+        let gitDir = join(directory, ".git");
+        if (!readdirSync(directory).includes(".git"))
+            return null;
+        try {
+            readdirSync(gitDir);
+        }
+        catch {
+            const pointer = /^gitdir:\s*(.+)$/m.exec(readFileSync(gitDir, "utf8"))?.[1]?.trim();
+            if (!pointer)
+                return null;
+            gitDir = isAbsolute(pointer) ? pointer : join(directory, pointer);
+            const common = join(gitDir, "commondir");
+            if (existsSync(common)) {
+                const shared = readFileSync(common, "utf8").trim();
+                gitDir = isAbsolute(shared) ? shared : join(gitDir, shared);
+            }
+        }
+        const config = readFileSync(join(gitDir, "config"), "utf8");
+        return /\[remote "origin"\][^[]*?\burl\s*=\s*(\S+)/.exec(config)?.[1] ?? null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist-server/shared/provider-accounts.js

@@ -63,6 +63,35 @@ export const ACCOUNT_PROVIDERS = [
         id: "opencodeGo", kind: "apiKey", label: "OpenCode Go", billing: "subscription", driver: "opencodeGo", envVar: "OPENCODE_API_KEY",
         config: {}, keyUrl: "https://opencode.ai/go", signupUrl: "https://opencode.ai/go",
     },
+    // Permanent free tiers (docs/specs/free-models-in-auto): the last resort
+    // when every subscription and pay-per-use key is out (Erick's rule, a
+    // model or billing error never stops the user). Off by default
+    // (engineTiers.includeFree); never used for client-facing bots.
+    {
+        id: "openrouterFree", kind: "apiKey", label: "OpenRouter (free models)", billing: "free", driver: "openai-compat", envVar: "OPENROUTER_FREE_API_KEY", icon: "openrouter",
+        config: { url: "https://openrouter.ai/api/v1", apiKeyEnv: "OPENROUTER_FREE_API_KEY", model: "", provider: "" },
+        keyTest: { provider: "openaiCompat", url: "https://openrouter.ai/api/v1" }, keyUrl: "https://openrouter.ai/keys", signupUrl: "https://openrouter.ai/models?max_price=0",
+    },
+    {
+        id: "googleAiStudioFree", kind: "apiKey", label: "Google AI Studio (free tier)", billing: "free", driver: "openai-compat", envVar: "GOOGLE_AI_STUDIO_FREE_API_KEY", icon: "google",
+        config: { url: "https://generativelanguage.googleapis.com/v1beta/openai", apiKeyEnv: "GOOGLE_AI_STUDIO_FREE_API_KEY", model: "", provider: "" },
+        keyTest: { provider: "openaiCompat", url: "https://generativelanguage.googleapis.com/v1beta/openai" }, keyUrl: "https://aistudio.google.com/apikey",
+    },
+    {
+        id: "groqFree", kind: "apiKey", label: "Groq (free tier)", billing: "free", driver: "openai-compat", envVar: "GROQ_FREE_API_KEY",
+        config: { url: "https://api.groq.com/openai/v1", apiKeyEnv: "GROQ_FREE_API_KEY", model: "", provider: "" },
+        keyTest: { provider: "openaiCompat", url: "https://api.groq.com/openai/v1" }, keyUrl: "https://console.groq.com/keys",
+    },
+    {
+        id: "cerebrasFree", kind: "apiKey", label: "Cerebras (free tier)", billing: "free", driver: "openai-compat", envVar: "CEREBRAS_FREE_API_KEY",
+        config: { url: "https://api.cerebras.ai/v1", apiKeyEnv: "CEREBRAS_FREE_API_KEY", model: "", provider: "" },
+        keyTest: { provider: "openaiCompat", url: "https://api.cerebras.ai/v1" }, keyUrl: "https://cloud.cerebras.ai/platform/apikeys",
+    },
+    {
+        id: "nvidiaFree", kind: "apiKey", label: "NVIDIA NIM (free tier)", billing: "free", driver: "openai-compat", envVar: "NVIDIA_FREE_API_KEY",
+        config: { url: "https://integrate.api.nvidia.com/v1", apiKeyEnv: "NVIDIA_FREE_API_KEY", model: "", provider: "" },
+        keyTest: { provider: "openaiCompat", url: "https://integrate.api.nvidia.com/v1" }, keyUrl: "https://build.nvidia.com/settings/api-keys",
+    },
 ];
 export function accountProvider(id) {
     return ACCOUNT_PROVIDERS.find((provider) => provider.id === id);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chibitek/chibi",
-  "version": "0.1.171",
+  "version": "0.1.173",
   "description": "Atomic by Chibitek: run your AI team's server anywhere and pair your devices to it",
   "license": "Apache-2.0",
   "type": "module",

package/dist/assets/channel-DEJSSlVQ.js

@@ -1 +0,0 @@
-import{U as a,C as n}from"./mermaid.core-CE_M1v1e.js";const t=(r,o)=>a.lang.round(n.parse(r)[o]);export{t as c};

package/dist/assets/swimlanesDiagram-TC7HE7FX-Dh25zxzq.js

@@ -1,8 +0,0 @@
-import{c as r,s as e}from"./flowDiagram-KWPJA3E3-C7mfBfgt.js";import{_ as a}from"./mermaid.core-CE_M1v1e.js";import"./chunk-5VM5RSS4-CUyMXCSt.js";import"./chunk-XXDRQBXY-BavbGHGi.js";import"./chunk-WEXAMYUT-fupByVJn.js";import"./chunk-GWA4HPMP-DQ0bZK59.js";import"./channel-DEJSSlVQ.js";import"./index-DojGBgbN.js";var o=a(t=>`${e(t)}
-  .swimlane.cluster:not([data-color-id]) rect {
-    stroke: ${t.clusterBorder} !important;
-  }
-  [data-look="neo"].cluster rect {
-    filter: none;
-  }
-`,"getStyles"),s=o,u=r({styles:s});export{u as diagram};