agentcage 0.1.4 → 0.1.6

package/README.md

@@ -1,10 +1,10 @@
 # agentcage
 
 ```
- ▄▄▄ ▄▄▄▄ ▄▄▄▄ ▄▄▄▄  █   ▄▄▄▄  ▄▄▄ ▄▄▄▄ ▄▄▄▄
-▄▄▄█ █  █ █▄▄▄ █  █ ▀█▀  █    ▄▄▄█ █  █ █▄▄▄
-█▄▄█ ▀▀▀█ █▄▄▄ █  █  █▄▄ █▄▄▄ █▄▄█ ▀▀▀█ █▄▄▄
-     ▀▀▀▀                          ▀▀▀▀
+ ▄▄▄ ▄▄▄▄ ▄▄▄▄ ▄▄▄▄  █    ▄▄▄▄  ▄▄▄ ▄▄▄▄ ▄▄▄▄
+▄▄▄█ █  █ █▄▄▄ █  █ ▀█▀ • █    ▄▄▄█ █  █ █▄▄▄
+█▄▄█ ▀▀▀█ █▄▄▄ █  █  █▄▄  █▄▄▄ █▄▄█ ▀▀▀█ █▄▄▄
+     ▀▀▀▀                           ▀▀▀▀
 ```
 
 Isolated dev containers for AI coding agents. Each project gets its own Linux container. **The project source lives
@@ -60,8 +60,9 @@ Run `agentcage` .  The wizard will ask you for this:
   API key in your terminal. Additional Providers can be added later. 
 7. **An IDE** to open the container in when it's ready (Cursor, VS Code, Antigravity).
 
-Then it builds the container, adds it to OpenCode Desktop as server **ac-<name>** (a green project) with the project
-`/workspaces/<name>` already open, and opens the IDE.
+Then it builds the container, adds it to OpenCode Desktop as server **ac-&lt;name&gt;** (a green project with a generated
+128x128 icon: `ac` in small letters over the first three letters of the name) with the project `/workspaces/<name>` already
+open, and opens the IDE.
 
 The same works without the dialog:
 
@@ -81,12 +82,12 @@ agentcage start <name>          # start after a reboot, print the OpenCode serve
 agentcage shell <name>          # shell in the container (opencode, claude, git ... work here)
 agentcage open <name> [ide]     # Cursor (default), VS Code, or another VS Code-based IDE attached to the container
 agentcage provider <name>       # add model provider API keys to OpenCode in the container
-agentcage connect <name>        # (re)register the container in OpenCode Desktop
+agentcage connect <name>        # (re)register the container in OpenCode Desktop and refresh its project icon
 agentcage upgrade <name>        # rebuild with the Desktop app's OpenCode version (volumes kept)
 agentcage stop <name>
 agentcage remove <name>         # delete container, volumes and config
 agentcage version               # installed version and the latest on npm
-agentcage settings              # project color and name prefixes for new containers
+agentcage settings              # project color, name prefixes, clean up dead containers
 agentcage doctor
 agentcage adopt <name>          # import a container made by the old bash scripts in legacy/
 ```
@@ -106,6 +107,10 @@ created afterwards.
 | OpenCode server prefix | `ac-` | the server's name in OpenCode Desktop |
 | OpenCode project prefix | `ac-` | the project's name in OpenCode (the folder stays `/workspaces/<name>`) |
 
+**Clean up dead containers** (also in Settings) lists leftovers of containers that no longer exist in Docker: agentcage
+configs and OpenCode Desktop servers. Stopped containers are kept. A config whose volumes still hold code is not
+preselected, because removing it deletes those volumes.
+
 ## Git push access
 
 The copy in the container is separate from your laptop's, so changes leave the container via **git push**. The dialog offers two ways:
@@ -130,6 +135,12 @@ agentcage reads the Desktop app's version (from `opencode-cli.version` in its in
 version in the container, because Desktop only talks to matching servers. `list`, `start` and `doctor` warn when the app has
 updated since; `agentcage upgrade <name>` rebuilds the container with the new version and keeps your code, logins and sessions.
 
+The OpenCode server is the container's main process, so it runs after every start: `agentcage start`, Docker Desktop, or an
+IDE starting the container. Containers made by older agentcage versions get this after one `agentcage upgrade <name>`.
+
+Cursor and VS Code open `/workspaces/<name>` however you attach (agentcage, Remote Explorer, Docker extension, recent list):
+agentcage sets the folder in the IDE's attached-container config for the container.
+
 Desktop has no API or deep link for adding a server, so agentcage writes the app's own state DB (`drafts.sqlite` in the
 app's data folder, backed up as `drafts.sqlite.agentcage-backup`). **The app must be closed for this.** The dialog asks you
 to close it. This relies on the app's internal storage format (written against Desktop 2.0.23), so a future app update may

package/bin/agentcage.js

@@ -4,7 +4,7 @@ import { parseArgs } from 'node:util';
 import * as p from '@clack/prompts';
 import { adoptContainer, listContainers, loadContainer, removeContainer, saveContainer, state, up, writeDevcontainer, openIde, ws } from '../src/container.js';
 import { ask, connectionInfo, newWizard, providerFlow, registerFlow, settingsWizard } from '../src/wizard.js';
-import { detectDesktop, latestVersion } from '../src/opencode.js';
+import { detectDesktop, latestVersion, setupProject } from '../src/opencode.js';
 import { ok, run } from '../src/run.js';
 
 process.removeAllListeners('warning'); // hide node:sqlite ExperimentalWarning
@@ -19,11 +19,11 @@ const HELP = `agentcage: isolated dev containers for AI coding agents
   agentcage stop <name>
   agentcage shell <name>            shell in the container (run opencode, claude, git ... here)
   agentcage open <name> [ide]       open Cursor (default), VS Code or another VS Code-based IDE attached to the container
-  agentcage connect <name>          (re)register the container in OpenCode Desktop (app must be closed)
+  agentcage connect <name>          (re)register the container in OpenCode Desktop and refresh its project icon (app must be closed)
   agentcage provider <name>         add model provider API keys to OpenCode in the container
   agentcage upgrade <name>          rebuild with the Desktop app's OpenCode version (volumes kept)
   agentcage remove <name>           delete container, volumes and config
-  agentcage settings                project color and name prefixes for new containers
+  agentcage settings                project color, name prefixes, clean up dead containers
   agentcage version | -v            installed version, and the latest on npm (update: npm i -g agentcage@latest)
   agentcage doctor                  check Docker, Node and OpenCode Desktop
   agentcage adopt <name>            import a container made by the old devbox bash scripts
@@ -73,7 +73,11 @@ const commands = {
     const b = container(); await start(b); openIde(b, arg2 ?? f.ide ?? 'cursor');
     if (b.git === 'token') p.log.warn('The IDE forwards your SSH agent into the container. Turn it off in the IDE settings to keep pushes limited to the repo token (see README).');
   },
-  async connect() { await registerFlow(container()); },
+  async connect() {
+    const b = container();
+    await start(b).then(() => setupProject(b)).catch(e => p.log.warn(`Could not set the project name and icon in OpenCode: ${e.message}`));
+    await registerFlow(b);
+  },
   async provider() { const b = container(); await start(b); await providerFlow(b, csv(f.providers)); },
   async upgrade() {
     const b = container(), v = detectDesktop().version ?? await latestVersion();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentcage",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Isolated dev containers for AI coding agents (OpenCode, Claude Code), connected to OpenCode Desktop",
   "type": "module",
   "bin": {

package/src/container.js

@@ -41,9 +41,14 @@ export function nameTaken(n) {
 const bindable = port => new Promise(r => {
   const s = createServer().once('error', () => r(false)).listen(port, '127.0.0.1', () => s.close(() => r(true)));
 });
+// Host ports published by any Docker container, running or stopped (docker ps shows none for stopped ones)
+export function publishedPorts() {
+  const ids = runSync('docker', ['ps', '-aq']).split('\n').filter(Boolean);
+  const out = ids.length ? runSync('docker', ['inspect', '-f', '{{json .HostConfig.PortBindings}}', ...ids]) : '';
+  return new Set([...out.matchAll(/"HostPort":"(\d+)"/g)].map(m => +m[1]));
+}
 async function freePort() {
-  const used = new Set(listContainers().map(b => b.port));
-  for (const m of runSync('docker', ['ps', '-a', '--format', '{{.Ports}}']).matchAll(/:(\d+)->/g)) used.add(+m[1]);
+  const used = new Set([...listContainers().map(b => b.port), ...publishedPorts()]);
   for (let p = 4100; ; p++) if (!used.has(p) && (await bindable(p))) return p;
 }
 
@@ -60,18 +65,21 @@ export function writeDevcontainer(b) {
     workspaceFolder: ws(b),
     mounts: [`source=${b.volumes.home},target=/home/node,type=volume`],
     runArgs: [`--name=${b.container}`, `--label=agentcage.name=${b.name}`, ...(oc ? ['-p', `127.0.0.1:${b.port}:4096`] : [])],
-    containerEnv: oc ? { OPENCODE_SERVER_PASSWORD: b.password } : {},
+    containerEnv: { AGENTCAGE_WORKSPACE: ws(b), ...(oc && { OPENCODE_SERVER_PASSWORD: b.password }) },
     features: Object.fromEntries(tools.filter(t => t.feature).map(t => [t.feature, {}])),
     remoteUser: 'node',
     init: true,
+    overrideCommand: false, // run the image's CMD (agentcage-start) on every start, not only on devcontainer up
     forwardPorts: [3000],
     postCreateCommand: 'agentcage-post-create',
-    ...(oc && { postStartCommand: 'setsid nohup opencode serve --hostname 0.0.0.0 --port 4096 > /tmp/opencode-serve.log 2>&1 &' }),
   };
   writeFileSync(join(dir, 'devcontainer.json'), JSON.stringify(cfg, null, 2) + '\n');
 }
 
-export const up = (b, rebuild) => devcontainer(['up', '--workspace-folder', b.dir, ...(rebuild ? ['--remove-existing-container'] : [])]);
+export async function up(b, rebuild) {
+  await devcontainer(['up', '--workspace-folder', b.dir, ...(rebuild ? ['--remove-existing-container'] : [])]);
+  pinIdeFolder(b);
+}
 export const state = b => runSync('docker', ['inspect', '-f', '{{.State.Status}}', b.container]) || 'missing';
 
 // o: { src, name, tools, git: 'token'|'forward'|'none', token, opencodeVersion }. step(label, fn) shows progress.
@@ -100,10 +108,35 @@ export async function removeContainer(b) {
   for (const v of Object.values(b.volumes)) await run('docker', ['volume', 'rm', v]).catch(() => {});
   rmSync(b.dir, { recursive: true, force: true });
   rmSync(join(ROOT, b.name), { recursive: true, force: true });
+  for (const d of ideConfigDirs()) rmSync(join(d, 'nameConfigs', `${b.container}.json`), { force: true });
+}
+
+// VS Code-based IDEs keep an attached-container config per container name (nameConfigs) and per image (imageConfigs).
+// Its workspaceFolder decides the folder that opens on any attach (Remote Explorer, Docker extension, recent list),
+// so point both at the code. Other keys in those files (e.g. extensions) are kept.
+const CONFIG_HOME = P => P === 'win32' ? process.env.APPDATA ?? '' : P === 'darwin' ? join(homedir(), 'Library', 'Application Support')
+  : process.env.XDG_CONFIG_HOME || join(homedir(), '.config');
+const ideConfigDirs = (root = CONFIG_HOME(process.platform)) => (existsSync(root) ? readdirSync(root) : [])
+  .map(app => join(root, app, 'User', 'globalStorage')).filter(existsSync)
+  .flatMap(gs => readdirSync(gs).filter(d => d.endsWith('remote-containers')).map(d => join(gs, d)));
+export function pinIdeFolder(b) {
+  const image = runSync('docker', ['inspect', '-f', '{{.Config.Image}}', b.container]);
+  for (const d of ideConfigDirs()) {
+    // image configs: only fix existing ones, they are shared by every container of that image
+    for (const f of [join(d, 'nameConfigs', `${b.container}.json`), ...(image ? [join(d, 'imageConfigs', `${image}.json`)].filter(existsSync) : [])]) {
+      try {
+        const cfg = existsSync(f) ? JSON.parse(readFileSync(f, 'utf8')) : {};
+        if (cfg.workspaceFolder === ws(b)) continue;
+        mkdirSync(join(f, '..'), { recursive: true });
+        writeFileSync(f, JSON.stringify({ ...cfg, workspaceFolder: ws(b) }, null, '\t'));
+      } catch {} // not plain JSON (hand-edited with comments): leave it alone
+    }
+  }
 }
 
 // Opens a VS Code-based IDE attached to the running container
 export function openIde(b, ide) {
+  pinIdeFolder(b);
   const hex = Buffer.from(JSON.stringify({ containerName: `/${b.container}` })).toString('hex');
   launch(ide, ['--folder-uri', `vscode-remote://attached-container+${hex}${ws(b)}`]);
 }

package/src/icon.js

@@ -0,0 +1,95 @@
+// Generates the 128x128 project icon for OpenCode: dark green background, white text in two rows —
+// the project prefix ("ac") in small letters on top, the first three letters of the container name below.
+// A hand-rolled PNG encoder (zlib + CRC) with a 5x7 bitmap font keeps this dependency-free.
+import { deflateSync } from 'node:zlib';
+
+const SIZE = 128, SS = 4, BG = [20, 83, 45], FG = [255, 255, 255]; // SS: supersampling for smooth edges
+
+// 5x7 pixel font ('#' = ink); lowercase letters, digits and - cover all names and prefixes
+const FONT = {
+  a: ['.....', '.....', '.###.', '....#', '.####', '#...#', '.####'],
+  b: ['#....', '#....', '####.', '#...#', '#...#', '#...#', '####.'],
+  c: ['.....', '.....', '.####', '#....', '#....', '#....', '.####'],
+  d: ['....#', '....#', '.####', '#...#', '#...#', '#...#', '.####'],
+  e: ['.....', '.....', '.###.', '#...#', '#####', '#....', '.###.'],
+  f: ['..##.', '.#...', '####.', '.#...', '.#...', '.#...', '.#...'],
+  g: ['.....', '.....', '.###.', '#...#', '.####', '....#', '.###.'],
+  h: ['#....', '#....', '####.', '#...#', '#...#', '#...#', '#...#'],
+  i: ['..#..', '.....', '..#..', '..#..', '..#..', '..#..', '..#..'],
+  j: ['....#', '.....', '....#', '....#', '....#', '#...#', '.###.'],
+  k: ['#....', '#....', '#...#', '#..#.', '###..', '#..#.', '#...#'],
+  l: ['..#..', '..#..', '..#..', '..#..', '..#..', '..#..', '..#..'],
+  m: ['.....', '.....', '##.##', '#.#.#', '#.#.#', '#.#.#', '#.#.#'],
+  n: ['.....', '.....', '####.', '#...#', '#...#', '#...#', '#...#'],
+  o: ['.....', '.....', '.###.', '#...#', '#...#', '#...#', '.###.'],
+  p: ['.....', '.....', '####.', '#...#', '#...#', '####.', '#....'],
+  q: ['.....', '.....', '.####', '#...#', '#...#', '.####', '....#'],
+  r: ['.....', '.....', '#.##.', '##..#', '#....', '#....', '#....'],
+  s: ['.....', '.....', '.####', '#....', '.###.', '....#', '####.'],
+  t: ['.#...', '.#...', '###..', '.#...', '.#...', '.#...', '.##..'],
+  u: ['.....', '.....', '#...#', '#...#', '#...#', '#...#', '.###.'],
+  v: ['.....', '.....', '#...#', '#...#', '#...#', '.#.#.', '..#..'],
+  w: ['.....', '.....', '#...#', '#...#', '#.#.#', '#.#.#', '.#.#.'],
+  x: ['.....', '.....', '#...#', '.#.#.', '..#..', '.#.#.', '#...#'],
+  y: ['.....', '.....', '#...#', '#...#', '.#.#.', '..#..', '..#..'],
+  z: ['.....', '.....', '####.', '...#.', '..#..', '.#...', '####.'],
+  0: ['.###.', '#...#', '#..##', '#.#.#', '##..#', '#...#', '.###.'],
+  1: ['..#..', '.##..', '..#..', '..#..', '..#..', '..#..', '.###.'],
+  2: ['.###.', '#...#', '....#', '...#.', '..#..', '.#...', '#####'],
+  3: ['.###.', '#...#', '....#', '..##.', '....#', '#...#', '.###.'],
+  4: ['...#.', '..##.', '.#.#.', '#..#.', '#####', '...#.', '...#.'],
+  5: ['#####', '#....', '####.', '....#', '....#', '#...#', '.###.'],
+  6: ['.###.', '#....', '#....', '####.', '#...#', '#...#', '.###.'],
+  7: ['#####', '....#', '...#.', '..#..', '..#..', '..#..', '..#..'],
+  8: ['.###.', '#...#', '#...#', '.###.', '#...#', '#...#', '.###.'],
+  9: ['.###.', '#...#', '#...#', '.####', '....#', '....#', '.###.'],
+  '-': ['.....', '.....', '.....', '.###.', '.....', '.....', '.....'],
+};
+
+const crcTable = Array.from({ length: 256 }, (_, n) => { let c = n; for (let k = 0; k < 8; k++) c = c & 1 ? 0xEDB88320 ^ (c >>> 1) : c >>> 1; return c; });
+const crc32 = buf => { let c = -1; for (const b of buf) c = crcTable[(c ^ b) & 255] ^ (c >>> 8); return (c ^ -1) >>> 0; };
+const chunk = (type, data) => { const t = Buffer.from(type), head = Buffer.alloc(8), crc = Buffer.alloc(4);
+  head.writeUInt32BE(data.length); t.copy(head, 4); crc.writeUInt32BE(crc32(Buffer.concat([t, data])));
+  return Buffer.concat([head, data, crc]); };
+
+const png = rgba => {
+  const ihdr = Buffer.alloc(13), stride = SIZE * 4, raw = Buffer.alloc((stride + 1) * SIZE);
+  ihdr.writeUInt32BE(SIZE); ihdr.writeUInt32BE(SIZE, 4); ihdr[8] = 8; ihdr[9] = 6; // 8-bit RGBA
+  for (let y = 0; y < SIZE; y++) rgba.copy(raw, y * (stride + 1) + 1, y * stride, (y + 1) * stride);
+  return Buffer.concat([Buffer.from('89504e470d0a1a0a', 'hex'), chunk('IHDR', ihdr), chunk('IDAT', deflateSync(raw)), chunk('IEND', Buffer.alloc(0))]);
+};
+
+// Draws one text row centered horizontally; s and y are in final-image pixels (rendered at SS x)
+const draw = (img, dim, text, s, y) => {
+  let x = Math.round((SIZE - (text.length * 6 - 1) * s) / 2) * SS;
+  for (const ch of text) {
+    const g = FONT[ch];
+    if (g) for (let r = 0; r < 7; r++) for (let c = 0; c < 5; c++) if (g[r][c] === '#')
+      for (let dy = 0; dy < s * SS; dy++) for (let dx = 0; dx < s * SS; dx++) {
+        const i = ((y * SS + r * s * SS + dy) * dim + x + c * s * SS + dx) * 3;
+        img[i] = FG[0]; img[i + 1] = FG[1]; img[i + 2] = FG[2];
+      }
+    x += 6 * s * SS;
+  }
+};
+
+// The icon as a data URL for OpenCode's project icon override
+export const projectIcon = (name, prefix = 'ac') => {
+  const dim = SIZE * SS, img = Buffer.alloc(dim * dim * 3);
+  for (let i = 0; i < dim * dim; i++) { img[i * 3] = BG[0]; img[i * 3 + 1] = BG[1]; img[i * 3 + 2] = BG[2]; }
+  const rows = [[prefix.replace(/[^a-z0-9]/g, ''), 3], [name.slice(0, 3), 6]].filter(([t]) => t);
+  const gap = 12, total = rows.reduce((n, [, s]) => n + 7 * s, 0) + gap * (rows.length - 1);
+  let y = Math.round((SIZE - total) / 2);
+  for (const [t, s] of rows) { draw(img, dim, t, s, y); y += 7 * s + gap; }
+  const out = Buffer.alloc(SIZE * SIZE * 4); // downsample SS x SS blocks for smooth edges
+  for (let py = 0; py < SIZE; py++) for (let px = 0; px < SIZE; px++) {
+    let r = 0, g = 0, b = 0;
+    for (let dy = 0; dy < SS; dy++) for (let dx = 0; dx < SS; dx++) {
+      const i = ((py * SS + dy) * dim + px * SS + dx) * 3;
+      r += img[i]; g += img[i + 1]; b += img[i + 2];
+    }
+    const o = (py * SIZE + px) * 4, n = SS * SS;
+    out[o] = Math.round(r / n); out[o + 1] = Math.round(g / n); out[o + 2] = Math.round(b / n); out[o + 3] = 255;
+  }
+  return `data:image/png;base64,${png(out).toString('base64')}`;
+};

package/src/opencode.js

@@ -2,6 +2,7 @@
 import { copyFileSync, existsSync, readFileSync, readdirSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
+import { projectIcon } from './icon.js';
 import { ok, run, runSync } from './run.js';
 import { loadSettings } from './settings.js';
 
@@ -33,29 +34,54 @@ export const desktopRunning = () => P === 'win32'
 
 export const latestVersion = async () => (await (await fetch('https://registry.npmjs.org/@opencode/cli/latest')).json()).version;
 
-// Desktop has no API or deep link for adding a server, so write its state DB (app must be closed). A backup is kept.
-export async function connectDesktop(container) {
+// Desktop has no API or deep link for adding a server, so edit its state DB (app must be closed). A backup is kept.
+const urlOf = x => (typeof x === 'string' ? x : x.http?.url ?? x.url);
+async function serverState(edit) {
   const { db, hasDb } = detectDesktop();
   if (!hasDb) throw new Error(`OpenCode Desktop state not found at ${db}. Open the app once first.`);
-  if (desktopRunning()) throw new Error('OpenCode Desktop is running. Close it first.');
-  copyFileSync(db, db + '.agentcage-backup');
+  if (edit && desktopRunning()) throw new Error('OpenCode Desktop is running. Close it first.');
   const { DatabaseSync } = await import('node:sqlite');
-  const d = new DatabaseSync(db), url = `http://127.0.0.1:${container.port}`, dir = `/workspaces/${container.name}`;
+  const d = new DatabaseSync(db, { readOnly: !edit });
   const row = d.prepare("select value from state where name='opencode.global.dat' and key='server'").get();
   const s = { list: [], hidden: {}, projects: {}, lastProject: {}, recentlyClosed: {}, ...(row && JSON.parse(row.value)) };
-  const urlOf = x => (typeof x === 'string' ? x : x.http?.url ?? x.url);
-  s.list = s.list.filter(x => urlOf(x) !== url).concat({ type: 'http', http: { url, password: container.password }, displayName: serverName(container) });
-  s.projects[url] = [{ worktree: dir, expanded: true }];
-  s.lastProject[url] = dir;
-  d.prepare(`insert into state(name, key, value, updated_at) values ('opencode.global.dat', 'server', ?, ?)
-    on conflict(name, key) do update set value = excluded.value, updated_at = excluded.updated_at`).run(JSON.stringify(s), Date.now());
+  if (edit) {
+    copyFileSync(db, db + '.agentcage-backup');
+    edit(s, d);
+    d.prepare(`insert into state(name, key, value, updated_at) values ('opencode.global.dat', 'server', ?, ?)
+      on conflict(name, key) do update set value = excluded.value, updated_at = excluded.updated_at`).run(JSON.stringify(s), Date.now());
+  }
   d.close();
+  return s;
 }
 
+export const connectDesktop = c => serverState(s => {
+  const url = `http://127.0.0.1:${c.port}`, dir = `/workspaces/${c.name}`;
+  s.list = s.list.filter(x => urlOf(x) !== url).concat({ type: 'http', http: { url, password: c.password }, displayName: serverName(c) });
+  s.projects[url] = [{ worktree: dir, expanded: true }];
+  s.lastProject[url] = dir;
+});
+
+// Servers on this machine (127.0.0.1:<port>) registered in Desktop: [{ url, port, name }]
+export const desktopServers = async () => (await serverState()).list.map(x => ({ url: urlOf(x), name: x.displayName ?? urlOf(x) }))
+  .map(x => ({ ...x, port: +x.url?.match(/^https?:\/\/(?:127\.0\.0\.1|localhost):(\d+)/)?.[1] })).filter(x => x.port);
+
+// Removes servers with everything Desktop keeps per server URL (UI history such as tabs is left to the app)
+export const removeDesktopServers = urls => serverState((s, d) => {
+  s.list = s.list.filter(x => !urls.includes(urlOf(x)));
+  for (const k of ['hidden', 'projects', 'lastProject', 'recentlyClosed']) for (const u of urls) delete s[k][u];
+  const del = d.prepare("delete from state where name='opencode.global.dat' and key=?");
+  for (const u of urls) del.run(u);
+  const row = d.prepare("select value from state where name='opencode.global.dat' and key='home.servers'").get(), h = row && JSON.parse(row.value);
+  if (h?.collapsed) {
+    for (const u of urls) delete h.collapsed[u];
+    d.prepare("update state set value=? where name='opencode.global.dat' and key='home.servers'").run(JSON.stringify(h));
+  }
+});
+
 // Names stored at creation; containers made before the settings existed use the current settings
 export const serverName = c => c.serverName ?? loadSettings().serverPrefix + c.name;
 
-// Sets the project's name and icon color in the container's OpenCode server. Asking about the folder creates the project first.
+// Sets the project's name and its generated icon in the container's OpenCode server. Asking about the folder creates the project first.
 // The server starts in the background after `devcontainer up`, so retry for ~30 s.
 export async function setupProject(c) {
   const s = loadSettings(), name = c.projectName ?? s.projectPrefix + c.name, color = c.color ?? s.color;
@@ -66,7 +92,7 @@ export async function setupProject(c) {
     try {
       await api(`/vcs?location[directory]=${encodeURIComponent(dir)}`);
       const { id } = (await api('/project')).find(x => x.canonical === dir);
-      return await api(`/project/${id}`, { method: 'PATCH', body: JSON.stringify({ name, icon: { color } }) });
+      return await api(`/project/${id}`, { method: 'PATCH', body: JSON.stringify({ name, icon: { color, override: projectIcon(c.name, s.projectPrefix) } }) });
     } catch (e) { if (i >= 15) throw e; await new Promise(r => setTimeout(r, 2000)); }
   }
 }

package/src/wizard.js

@@ -3,9 +3,9 @@ import * as p from '@clack/prompts';
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { AGENTS, DEV_TOOLS, PROVIDERS, hostInfo } from './catalog.js';
-import { cleanName, createContainer, nameTaken, openIde, ws } from './container.js';
+import { cleanName, createContainer, listContainers, nameTaken, openIde, publishedPorts, removeContainer, state, ws } from './container.js';
 import { isGitUrl, localRemote, parseRemote } from './git.js';
-import { connectDesktop, desktopRunning, detectDesktop, latestVersion, loginProvider, serverName, setupProject } from './opencode.js';
+import { connectDesktop, desktopRunning, desktopServers, detectDesktop, latestVersion, loginProvider, removeDesktopServers, serverName, setupProject } from './opencode.js';
 import { ok, runSync } from './run.js';
 import { COLORS, DEFAULTS, LABELS, loadSettings, saveSettings } from './settings.js';
 
@@ -46,15 +46,39 @@ async function waitForDocker() {
 // Registers the container in OpenCode Desktop, asking the user to close the app if needed
 export async function registerFlow(b, interactive = true) {
   if (!detectDesktop().hasDb) return p.note(connectionInfo(b), 'OpenCode Desktop not found. Add this server by hand');
-  while (desktopRunning()) {
-    if (!interactive) return p.log.warn(`OpenCode Desktop is open. Close it, then run: agentcage connect ${b.name}`);
-    const go = await ask(p.confirm({ message: 'Close OpenCode Desktop so the container can be added to it.', active: 'It is closed now', inactive: 'Skip for now' }));
-    if (!go) return p.log.info(`Later: agentcage connect ${b.name}`);
-  }
+  if (!interactive && desktopRunning()) return p.log.warn(`OpenCode Desktop is open. Close it, then run: agentcage connect ${b.name}`);
+  if (!(await desktopClosed('Close OpenCode Desktop so the container can be added to it.'))) return p.log.info(`Later: agentcage connect ${b.name}`);
   await connectDesktop(b);
   p.log.success(`OpenCode Desktop: added server "${serverName(b)}" with project ${ws(b)}`);
 }
 
+// Desktop's state can only be written while the app is closed. Returns false if the user skips.
+async function desktopClosed(message) {
+  while (desktopRunning()) if (!(await ask(p.confirm({ message, active: 'It is closed now', inactive: 'Skip for now' })))) return false;
+  return true;
+}
+
+// Leftovers of containers that no longer exist in Docker: agentcage configs (with their volumes) and OpenCode Desktop servers.
+// Stopped containers still exist and are kept. Configs whose volumes still hold code are not preselected.
+export async function cleanupFlow() {
+  const ports = publishedPorts(), dead = listContainers().filter(b => state(b) === 'missing');
+  const servers = detectDesktop().hasDb ? (await desktopServers()).filter(x => !ports.has(x.port)) : [];
+  const hasCode = b => ok('docker', ['volume', 'inspect', b.volumes.src]);
+  const options = [
+    ...dead.map(b => ({ value: `c:${b.name}`, label: `agentcage config: ${b.name}`, hint: hasCode(b) ? 'also deletes its volumes and the code in them' : 'no volumes left' })),
+    ...servers.map(x => ({ value: `s:${x.url}`, label: `OpenCode Desktop server: ${x.name}`, hint: x.url })),
+  ];
+  if (!options.length) return p.log.success('Nothing to clean up: every agentcage config and OpenCode server has a Docker container.');
+  const picked = await ask(p.multiselect({ message: 'Remove leftovers of containers that no longer exist?', options, required: false,
+    initialValues: options.filter(o => !dead.some(b => o.value === `c:${b.name}` && hasCode(b))).map(o => o.value) }));
+  for (const b of dead.filter(b => picked.includes(`c:${b.name}`))) { await removeContainer(b); p.log.success(`Removed ${b.name}`); }
+  const urls = servers.filter(x => picked.includes(`s:${x.url}`)).map(x => x.url);
+  if (!urls.length) return;
+  if (!(await desktopClosed('Close OpenCode Desktop so its servers can be removed.'))) return p.log.info('OpenCode Desktop servers were not removed.');
+  await removeDesktopServers(urls);
+  p.log.success(`Removed ${urls.length} server${urls.length > 1 ? 's' : ''} from OpenCode Desktop`);
+}
+
 // Hands the terminal to OpenCode's own key prompt for each provider
 export async function providerFlow(b, ids) {
   ids ??= await ask(p.multiselect({ message: 'Which providers should OpenCode use in this container?', options: PROVIDERS.map(x => ({ value: x.id, label: x.label, hint: x.hint })) }));
@@ -135,7 +159,7 @@ export async function newWizard(f = {}) {
     process.exit(1);
   }
   if (providers.length) await providerFlow(b, providers);
-  if (oc) await setupProject(b).catch(e => p.log.warn(`Could not set the project name and color in OpenCode: ${e.message}`));
+  if (oc) await setupProject(b).catch(e => p.log.warn(`Could not set the project name and icon in OpenCode: ${e.message}`));
   if (oc) await registerFlow(b, !f.yes);
   if (ide !== 'none') { openIde(b, ide); p.log.success('Opening the IDE attached to the container'); }
   p.outro([
@@ -152,8 +176,10 @@ export async function settingsWizard() {
   const s = loadSettings();
   for (;;) {
     const key = await ask(p.select({ message: 'Which setting? (applies to new containers)', options: [
-      ...Object.keys(DEFAULTS).map(k => ({ value: k, label: LABELS[k], hint: s[k] === '' ? 'none' : s[k] })), { value: '', label: 'Done' }] }));
+      ...Object.keys(DEFAULTS).map(k => ({ value: k, label: LABELS[k], hint: s[k] === '' ? 'none' : s[k] })),
+      { value: '-cleanup', label: 'Clean up dead containers', hint: 'configs and OpenCode servers whose container is gone' }, { value: '', label: 'Done' }] }));
     if (!key) break;
+    if (key === '-cleanup') { await cleanupFlow(); continue; }
     s[key] = await ask(key === 'color'
       ? p.select({ message: LABELS.color, initialValue: s.color, options: COLORS.map(c => ({ value: c, label: c, hint: c === 'gray' ? "OpenCode's default" : undefined })) })
       : p.text({ message: `${LABELS[key]} (empty for none)`, initialValue: s[key], defaultValue: '', validate: v => (/^[a-z0-9-]*$/.test(v ?? '') ? undefined : 'Use lowercase letters, digits and -') }));

package/template/Dockerfile

@@ -12,3 +12,8 @@ RUN if [ -n "$OPENCODE_VERSION" ]; then npm install -g @opencode/cli@${OPENCODE_
 
 COPY post-create.sh /usr/local/bin/agentcage-post-create
 RUN chmod +x /usr/local/bin/agentcage-post-create
+
+# Main process: starts the OpenCode server on every container start (devcontainer.json sets overrideCommand: false)
+COPY start.sh /usr/local/bin/agentcage-start
+RUN chmod +x /usr/local/bin/agentcage-start
+CMD ["agentcage-start"]

package/template/start.sh

@@ -0,0 +1,12 @@
+#!/bin/sh
+# Container main process. Keeps the OpenCode server running as the node user, from every container start
+# (docker start, Docker Desktop restart, an IDE starting it), and restarts it if it exits.
+if [ -n "$OPENCODE_SERVER_PASSWORD" ]; then
+  cd "${AGENTCAGE_WORKSPACE:-/tmp}"
+  while :; do
+    # node opens the log: root may not write a node-owned file in /tmp (fs.protected_regular)
+    runuser -u node -- sh -c 'exec opencode serve --hostname 0.0.0.0 --port 4096 >> /tmp/opencode-serve.log 2>&1'
+    sleep 2
+  done &
+fi
+exec sleep infinity