@generativereality/cctabs 0.1.4 → 0.2.0

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "cctabs",
   "description": "Claude Code tab manager. Terminal tabs as the UI, no tmux. Claude can orchestrate its own sibling sessions.",
-  "version": "0.1.4",
+  "version": "0.2.0",
   "author": {
     "name": "generativereality",
     "url": "https://cctabs.com"

package/dist/index.js

@@ -10,7 +10,7 @@ import { consola } from "consola";
 import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "fs";
 //#region package.json
 var name = "@generativereality/cctabs";
-var version = "0.1.4";
+var version = "0.2.0";
 var description = "Claude Code tab manager. Terminal tabs as the UI, no tmux.";
 var package_default = {
 	name,
@@ -540,6 +540,11 @@ function ensureConfigExists() {
 }
 //#endregion
 //#region src/core/open-session.ts
+function shellQuoteEnv$1(env) {
+	const entries = Object.entries(env);
+	if (!entries.length) return "";
+	return entries.map(([k, v]) => `${k}=${JSON.stringify(v)}`).join(" ") + " ";
+}
 /** Poll scrollback until a pattern is visible, then return. Rejects on timeout. */
 async function waitForScrollbackMatch(adapter, blockId, pattern, label, timeoutMs, pollInterval = 1e3) {
 	const deadline = Date.now() + timeoutMs;
@@ -554,7 +559,7 @@ async function waitForScrollbackMatch(adapter, blockId, pattern, label, timeoutM
 	throw new Error(`Timed out waiting for ${label}`);
 }
 async function openSession(opts) {
-	const { tabName, claudeCmd, workspaceQuery, initialPromptFile } = opts;
+	const { tabName, claudeCmd, workspaceQuery, initialPromptFile, envVars, modelOverride } = opts;
 	const dir = resolve(opts.dir.replace(/^~/, homedir()));
 	if (!existsSync(dir)) {
 		consola.error(`Directory does not exist: ${dir}`);
@@ -595,7 +600,9 @@ async function openSession(opts) {
 	}
 	const extraFlags = config.claude.flags.join(" ");
 	const namePart = claudeCmd.includes("--resume") ? "" : ` --name ${JSON.stringify(tabName)}`;
-	const cmd = `cd ${JSON.stringify(dir)} && claude${extraFlags ? " " + extraFlags : ""} ${claudeCmd.replace(/^claude\s*/, "")}${namePart}\r`;
+	const modelPart = modelOverride ? ` --model ${JSON.stringify(modelOverride)}` : "";
+	const envPrefix = envVars ? shellQuoteEnv$1(envVars) : "";
+	const cmd = `cd ${JSON.stringify(dir)} && ${envPrefix}claude${extraFlags ? " " + extraFlags : ""} ${claudeCmd.replace(/^claude\s*/, "")}${namePart}${modelPart}\r`;
 	await adapter.sendInput(blockId, cmd);
 	if (initialPromptFile) {
 		try {
@@ -615,6 +622,179 @@ async function openSession(opts) {
 	return tabId;
 }
 //#endregion
+//#region src/core/backends.ts
+/**
+* Backend presets. Each preset resolves to a set of env vars (prepended to the
+* shell command in the new tab) plus a Claude --model name.
+*
+* The default `anthropic` preset is a no-op: no env vars, no --model override —
+* Claude Code uses its built-in API connection.
+*
+* Ollama-backed presets point ANTHROPIC_BASE_URL at Ollama's
+* Anthropic-compatible /v1/messages endpoint (Ollama ≥ 0.14):
+*   https://docs.ollama.com/openai
+*
+* The `*-tee` variants route through the local logging proxy on :11500
+* (`npm run ollama-tee` in the motin-scripts repo) for wire-level inspection.
+*/
+const OLLAMA_LOCAL = "http://localhost:11434";
+const OLLAMA_TEE = "http://localhost:11500";
+/**
+* For Ollama-backed Claude Code sessions we pin the small/fast/haiku model to
+* the same model. Otherwise Claude Code's background "haiku" calls 404 against
+* Ollama because the haiku tag doesn't exist there.
+*/
+function ollamaEnv(baseUrl, model) {
+	return {
+		ANTHROPIC_BASE_URL: baseUrl,
+		ANTHROPIC_AUTH_TOKEN: "ollama",
+		ANTHROPIC_API_KEY: "",
+		ANTHROPIC_SMALL_FAST_MODEL: model,
+		ANTHROPIC_DEFAULT_HAIKU_MODEL: model
+	};
+}
+const BUILTIN_BACKENDS = {
+	anthropic: {
+		env: {},
+		model: "",
+		description: "Default Anthropic API (no override)"
+	},
+	kimi: {
+		env: ollamaEnv(OLLAMA_LOCAL, "kimi-k2.6:cloud"),
+		model: "kimi-k2.6:cloud",
+		description: "Kimi K2.6 via Ollama Cloud (Pro)"
+	},
+	"qwen-cloud": {
+		env: ollamaEnv(OLLAMA_LOCAL, "qwen3-coder-next:cloud"),
+		model: "qwen3-coder-next:cloud",
+		description: "Qwen3 Coder Next via Ollama Cloud"
+	},
+	"gemma-cloud": {
+		env: ollamaEnv(OLLAMA_LOCAL, "gemma4:31b-cloud"),
+		model: "gemma4:31b-cloud",
+		description: "Gemma4 31B via Ollama Cloud"
+	},
+	"qwen-local": {
+		env: ollamaEnv(OLLAMA_LOCAL, "qwen3-coder:30b"),
+		model: "qwen3-coder:30b",
+		description: "Qwen3 Coder 30B local (18GB)"
+	},
+	"qwen-next-local": {
+		env: ollamaEnv(OLLAMA_LOCAL, "qwen3-coder-next:q3_K_M"),
+		model: "qwen3-coder-next:q3_K_M",
+		description: "Qwen3 Coder Next Q3_K_M local (38GB) — needs `ollama create` import"
+	},
+	"gpt-oss": {
+		env: ollamaEnv(OLLAMA_LOCAL, "gpt-oss:20b"),
+		model: "gpt-oss:20b",
+		description: "gpt-oss 20B local (13GB)"
+	},
+	llama: {
+		env: ollamaEnv(OLLAMA_LOCAL, "llama3.1:8b"),
+		model: "llama3.1:8b",
+		description: "Llama 3.1 8B local (5GB) — note: garbles on Claude Code's 50k system prompt"
+	},
+	"gemma-local": {
+		env: ollamaEnv(OLLAMA_LOCAL, "gemma4:26b"),
+		model: "gemma4:26b",
+		description: "Gemma4 26B local (17GB)"
+	},
+	"kimi-tee": {
+		env: ollamaEnv(OLLAMA_TEE, "kimi-k2.6:cloud"),
+		model: "kimi-k2.6:cloud",
+		description: "Kimi via tee proxy (logs to /tmp/ollama-tee.log)"
+	},
+	"qwen-cloud-tee": {
+		env: ollamaEnv(OLLAMA_TEE, "qwen3-coder-next:cloud"),
+		model: "qwen3-coder-next:cloud",
+		description: "Qwen Cloud via tee proxy"
+	},
+	"qwen-next-local-tee": {
+		env: ollamaEnv(OLLAMA_TEE, "qwen3-coder-next:q3_K_M"),
+		model: "qwen3-coder-next:q3_K_M",
+		description: "Qwen Next local Q3 via tee proxy"
+	}
+};
+/**
+* Parse a `[backends.<name>]` section from the config TOML. Each section can
+* override env vars and/or model. Format:
+*
+*   [backends.my-preset]
+*   model = "qwen3-coder-next:cloud"
+*   base_url = "http://localhost:11434"
+*   auth_token = "ollama"          # optional, defaults to "ollama" if base_url is set
+*
+* Or for full control:
+*
+*   [backends.my-preset]
+*   model = "..."
+*   env_ANTHROPIC_BASE_URL = "..."
+*   env_ANTHROPIC_AUTH_TOKEN = "..."
+*/
+function loadCustomBackends() {
+	if (!existsSync(CONFIG_PATH)) return {};
+	const text = readFileSync(CONFIG_PATH, "utf-8");
+	const sections = {};
+	let section = null;
+	for (const raw of text.split("\n")) {
+		const line = raw.trim();
+		if (!line || line.startsWith("#")) continue;
+		if (line.startsWith("[") && line.endsWith("]")) {
+			section = line.slice(1, -1).trim();
+			sections[section] ??= {};
+			continue;
+		}
+		if (section?.startsWith("backends.") && line.includes("=")) {
+			const [rawKey, ...rest] = line.split("=");
+			const key = rawKey.trim();
+			const val = rest.join("=").trim();
+			if (val.startsWith("\"") && val.endsWith("\"")) sections[section][key] = val.slice(1, -1);
+		}
+	}
+	const result = {};
+	for (const [section, kv] of Object.entries(sections)) {
+		if (!section.startsWith("backends.")) continue;
+		const name = section.slice(9);
+		const model = kv.model ?? "";
+		const env = {};
+		if (kv.base_url) {
+			const baseUrl = kv.base_url;
+			const token = kv.auth_token ?? "ollama";
+			Object.assign(env, {
+				ANTHROPIC_BASE_URL: baseUrl,
+				ANTHROPIC_AUTH_TOKEN: token,
+				ANTHROPIC_API_KEY: ""
+			});
+			if (model) {
+				env.ANTHROPIC_SMALL_FAST_MODEL = model;
+				env.ANTHROPIC_DEFAULT_HAIKU_MODEL = model;
+			}
+		}
+		for (const [k, v] of Object.entries(kv)) if (k.startsWith("env_")) env[k.slice(4)] = v;
+		result[name] = {
+			env,
+			model,
+			description: kv.description ?? `User-defined preset (${CONFIG_PATH})`
+		};
+	}
+	return result;
+}
+function resolveBackend(name) {
+	if (!name) return null;
+	return loadCustomBackends()[name] ?? BUILTIN_BACKENDS[name] ?? null;
+}
+function listBackends() {
+	const custom = loadCustomBackends();
+	const merged = {
+		...BUILTIN_BACKENDS,
+		...custom
+	};
+	return Object.entries(merged).map(([name, spec]) => ({
+		name,
+		description: spec.description ?? ""
+	}));
+}
+//#endregion
 //#region src/commands/new.ts
 const newCommand = define({
 	name: "new",
@@ -647,6 +827,16 @@ const newCommand = define({
 			type: "string",
 			short: "p",
 			description: "Send initial prompt text once Claude is ready"
+		},
+		backend: {
+			type: "string",
+			short: "b",
+			description: "Backend preset (e.g. kimi, qwen-cloud, qwen-next-local, gpt-oss). Run `cctabs backends` to list."
+		},
+		model: {
+			type: "string",
+			short: "m",
+			description: "Override the model name (passed as --model to claude). Useful with --backend ollama-local."
 		}
 	},
 	async run(ctx) {
@@ -656,10 +846,24 @@ const newCommand = define({
 		const useWorktree = ctx.values.worktree ?? false;
 		const promptFile = ctx.values.file;
 		const promptText = ctx.values.prompt;
+		const backendName = ctx.values.backend;
+		const modelOverride = ctx.values.model;
 		if (!name) {
 			consola.error("Tab name is required");
 			process.exit(1);
 		}
+		let envVars;
+		let resolvedModel = modelOverride;
+		if (backendName) {
+			const backend = resolveBackend(backendName);
+			if (!backend) {
+				consola.error(`Unknown backend "${backendName}". Available:`);
+				for (const b of listBackends()) consola.log(`  ${b.name.padEnd(22)} ${b.description}`);
+				process.exit(1);
+			}
+			envVars = backend.env;
+			resolvedModel ??= backend.model || void 0;
+		}
 		let initialPromptFile;
 		if (promptText) {
 			initialPromptFile = join(tmpdir(), `cctabs-prompt-${Date.now()}.txt`);
@@ -670,10 +874,13 @@ const newCommand = define({
 			dir,
 			claudeCmd: useWorktree ? `claude --worktree ${JSON.stringify(name)}` : "claude",
 			workspaceQuery: workspace,
-			initialPromptFile
+			initialPromptFile,
+			envVars,
+			modelOverride: resolvedModel
 		});
-		const suffix = useWorktree ? ` (worktree: .claude/worktrees/${name})` : "";
-		consola.success(`Tab "${name}" [${tabId.slice(0, 8)}] → claude at ${dir}${suffix}`);
+		const wt = useWorktree ? ` (worktree: .claude/worktrees/${name})` : "";
+		const be = backendName ? ` [backend: ${backendName}${resolvedModel ? ` → ${resolvedModel}` : ""}]` : "";
+		consola.success(`Tab "${name}" [${tabId.slice(0, 8)}] → claude at ${dir}${wt}${be}`);
 	}
 });
 //#endregion
@@ -904,6 +1111,11 @@ function expandSessionId(input, dir) {
 }
 //#endregion
 //#region src/commands/resume.ts
+function shellQuoteEnv(env) {
+	const entries = Object.entries(env);
+	if (!entries.length) return "";
+	return entries.map(([k, v]) => `${k}=${JSON.stringify(v)}`).join(" ") + " ";
+}
 function formatAge(mtimeMs) {
 	const mins = Math.round((Date.now() - mtimeMs) / 6e4);
 	if (mins < 60) return `${mins}m ago`;
@@ -932,6 +1144,16 @@ const resumeCommand = define({
 			type: "string",
 			short: "s",
 			description: "Session ID to resume (use when multiple sessions share the same name)"
+		},
+		backend: {
+			type: "string",
+			short: "b",
+			description: "Backend preset (e.g. kimi, qwen-cloud, qwen-next-local). Run `cctabs backends` to list."
+		},
+		model: {
+			type: "string",
+			short: "m",
+			description: "Override the model name (passed as --model to claude)."
 		}
 	},
 	async run(ctx) {
@@ -942,6 +1164,20 @@ const resumeCommand = define({
 			process.exit(1);
 		}
 		const explicitSession = ctx.values.session;
+		const backendName = ctx.values.backend;
+		const modelOverride = ctx.values.model;
+		let envVars;
+		let resolvedModel = modelOverride;
+		if (backendName) {
+			const backend = resolveBackend(backendName);
+			if (!backend) {
+				consola.error(`Unknown backend "${backendName}". Available:`);
+				for (const b of listBackends()) consola.log(`  ${b.name.padEnd(22)} ${b.description}`);
+				process.exit(1);
+			}
+			envVars = backend.env;
+			resolvedModel ??= backend.model || void 0;
+		}
 		let sessionId;
 		if (explicitSession) {
 			const expanded = expandSessionId(explicitSession, dir) ?? expandSessionId(explicitSession);
@@ -1005,14 +1241,18 @@ const resumeCommand = define({
 					const newTabId = await openSession({
 						tabName: name,
 						dir,
-						claudeCmd: `claude --resume ${sessionId} --name ${JSON.stringify(name)}`
+						claudeCmd: `claude --resume ${sessionId} --name ${JSON.stringify(name)}`,
+						envVars,
+						modelOverride: resolvedModel
 					});
 					consola.success(`Tab "${name}" [${newTabId.slice(0, 8)}] → claude --resume ${sessionId.slice(0, 8)}… at ${dir} (recreated)`);
 					return;
 				}
 			}
 			const extraFlags = loadConfig().claude.flags.join(" ");
-			const cmd = `cd ${JSON.stringify(dir)} && claude${extraFlags ? " " + extraFlags : ""} --resume ${sessionId} --name ${JSON.stringify(name)}\r`;
+			const envPrefix = envVars ? shellQuoteEnv(envVars) : "";
+			const modelPart = resolvedModel ? ` --model ${JSON.stringify(resolvedModel)}` : "";
+			const cmd = `cd ${JSON.stringify(dir)} && ${envPrefix}claude${extraFlags ? " " + extraFlags : ""} --resume ${sessionId} --name ${JSON.stringify(name)}${modelPart}\r`;
 			await adapter.sendInput(termBlock.blockid, cmd);
 			let verified = false;
 			const deadline = Date.now() + 15e3;
@@ -1032,7 +1272,9 @@ const resumeCommand = define({
 			const tabId = await openSession({
 				tabName: name,
 				dir,
-				claudeCmd: `claude --resume ${sessionId} --name ${JSON.stringify(name)}`
+				claudeCmd: `claude --resume ${sessionId} --name ${JSON.stringify(name)}`,
+				envVars,
+				modelOverride: resolvedModel
 			});
 			consola.success(`Tab "${name}" [${tabId.slice(0, 8)}] → claude --resume ${sessionId.slice(0, 8)}… at ${dir} (new tab)`);
 		} else {
@@ -1040,7 +1282,9 @@ const resumeCommand = define({
 			const tabId = await openSession({
 				tabName: name,
 				dir,
-				claudeCmd: "claude"
+				claudeCmd: "claude",
+				envVars,
+				modelOverride: resolvedModel
 			});
 			consola.success(`Tab "${name}" [${tabId.slice(0, 8)}] → claude at ${dir} (new tab, no prior session found)`);
 		}
@@ -1497,6 +1741,19 @@ const restoreCommand = define({
 	}
 });
 //#endregion
+//#region src/commands/backends.ts
+const backendsCommand = define({
+	name: "backends",
+	description: "List available Claude Code backend presets (Anthropic, Ollama Cloud, local Ollama)",
+	args: {},
+	async run() {
+		consola.log("Available backends:\n");
+		for (const b of listBackends()) consola.log(`  ${b.name.padEnd(22)} ${b.description}`);
+		consola.log("\nUsage:  cctabs new <tab> <dir> --backend <name>");
+		consola.log("Add custom presets in ~/.config/cctabs/config.toml under [backends.<name>].");
+	}
+});
+//#endregion
 //#region src/commands/index.ts
 const defaultCommand = define({
 	name: "cctabs",
@@ -1518,7 +1775,8 @@ const subCommands = new Map([
 	["scrollback", scrollbackCommand],
 	["send", sendCommand],
 	["config", configCommand],
-	["restore", restoreCommand]
+	["restore", restoreCommand],
+	["backends", backendsCommand]
 ]);
 async function run() {
 	await cli(process.argv.slice(2), defaultCommand, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@generativereality/cctabs",
-  "version": "0.1.4",
+  "version": "0.2.0",
   "description": "Claude Code tab manager. Terminal tabs as the UI, no tmux.",
   "type": "module",
   "bin": {

package/skills/cctabs/SKILL.md

@@ -70,6 +70,7 @@ cctabs new fix-api ~/Dev/myapp --worktree --prompt "checkout PR #102 and fix tes
 cctabs sessions                          # list all tabs with session status
 cctabs list                              # list all workspaces, tabs, and blocks
 cctabs new <name> [dir] [-w workspace] [-p "prompt"] [-f file]  # new tab + claude
+cctabs new <name> [dir] -b <preset>      # new tab on a non-Anthropic backend (Ollama)
 cctabs resume <name> [dir]               # resume last session (reuses tab or creates one)
 cctabs restore [dir] [--dry]             # resume every dead tab (e.g. after a reboot)
 cctabs fork <tab-name> [-n new-name]     # fork session into new tab (--resume <id> --fork-session)
@@ -77,9 +78,74 @@ cctabs close <name-or-id>                # close a tab
 cctabs rename <name-or-id> <new-name>    # rename a tab
 cctabs scrollback <tab-or-block> [n]    # read terminal output (default: 50 lines)
 cctabs send <tab-or-block> [text]        # send input — arg, --file, or stdin pipe
+cctabs backends                          # list available backend presets
 cctabs config                            # show config and path
 ```
 
+## Backends: running Claude Code on Ollama / Kimi / Qwen / local models
+
+By default, `cctabs new` runs `claude` against the Anthropic API. Pass `--backend <preset>` (or `-b`) to launch the tab against a different model provider — useful for cheap/free scratch sessions, privacy-sensitive work, or experimenting with frontier open-weight models.
+
+`cctabs` does this by prepending the right env vars (`ANTHROPIC_BASE_URL`, `ANTHROPIC_AUTH_TOKEN`, `ANTHROPIC_DEFAULT_HAIKU_MODEL`, etc.) and `--model <name>` to the `claude` command in the new tab.
+
+### Built-in presets
+
+Run `cctabs backends` for the live list. Common ones:
+
+| Preset | What it is | When to use |
+|---|---|---|
+| `anthropic` (default) | Anthropic API | Production / coding work where capability matters |
+| `kimi` | Kimi K2.6 via Ollama Cloud (Pro tier) | Cheap frontier alternative; ~5s/turn |
+| `qwen-cloud` | Qwen3 Coder Next via Ollama Cloud | Fastest Pro option (~3.8s/turn) |
+| `gemma-cloud` | Gemma4 31B via Ollama Cloud | Cheap general-purpose |
+| `qwen-local` | Qwen3 Coder 30B local (18GB) | Offline / private; slow on M1 |
+| `qwen-next-local` | Qwen3 Coder Next Q3_K_M local (38GB) | Private + most capable local; needs `ollama create` import |
+| `gpt-oss` | gpt-oss 20B local (13GB) | Private; slow; ~100s/turn for 50k system prompt |
+| `llama` | Llama 3.1 8B local | Fast but garbles inside Claude Code's 50k system prompt — capability gate |
+| `*-tee` | Same as above but routed through `:11500` proxy | Wire-level inspection (`ollama-tee` proxy must be running) |
+
+### Cost × privacy framing
+
+Two axes matter:
+
+1. **Cost** — Anthropic Pro $20/mo or Max ($100/$200/mo); Ollama Cloud Pro $20/mo (3 concurrent, includes Kimi/Qwen Cloud); local = free but hardware-bound
+2. **Privacy** — Anthropic API: Anthropic sees prompts. Ollama Cloud: Ollama sees prompts. Local: nothing leaves the laptop
+
+Match the tier to the task:
+- Sensitive prompts (client code, customer data) → `qwen-next-local` or `gpt-oss`
+- Routine exploration / orchestration → `anthropic` (default)
+- Cost-sensitive bulk work → `kimi` or `qwen-cloud`
+
+### Examples
+
+```bash
+# Spin up a tab on Kimi for a side experiment
+cctabs new explore-kimi ~/Dev/myapp -b kimi -p "explore alternative API designs"
+
+# Local privacy session, slower but no data leaves the laptop
+cctabs new private-refactor ~/Dev/clientwork -b qwen-next-local -W
+
+# Compare two models on the same task in parallel
+cctabs new task-anthropic ~/Dev/myapp -p "implement spec X"
+cctabs new task-kimi ~/Dev/myapp -b kimi -p "implement spec X"
+
+# Custom local Ollama tag not in built-in presets:
+cctabs new x ~/Dev/myapp -b qwen-local -m my-custom-tag:latest
+```
+
+### Caveats
+
+- **Local backends are slow on M1.** A Claude Code turn against the local 50k-token system prompt takes ~100s prefill + generation on M1 Max. Only worth it for non-time-sensitive private work.
+- **Llama 3.1 8B garbles tool calls** under Claude Code's system prompt. Capability gate, not a bug.
+- **Ollama Cloud Pro requires `ollama signin`** (one-time). Free tier denies cloud-tagged models.
+- **Custom presets** can be added in `~/.config/cctabs/config.toml`:
+  ```toml
+  [backends.my-preset]
+  model = "qwen3-coder-next:cloud"
+  base_url = "http://localhost:11434"
+  description = "My custom preset"
+  ```
+
 ## Workflow: Checking What's Running
 
 Before starting new sessions, always check what's already active: