@mickaelroger78/opencode-manager 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 opencode-manager contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,213 @@
+# opencode-manager
+
+`opencode-manager` is a Go TUI for managing isolated OpenCode workspaces.
+
+It lets you run OpenCode inside a dedicated per-project container and attach to it from the host. Each workspace gets its own home directory, generated OpenCode configuration, selected tools, selected credentials, and long-lived container.
+
+## Why
+
+Running OpenCode directly on a developer machine can give it access to too much: environment variables, cloud accounts, Kubernetes clusters, SSH keys, tokens, and local config files.
+
+Running OpenCode in a generic VM or container gives it access to almost nothing, but then every project needs to be manually reconfigured.
+
+`opencode-manager` solves this by creating one isolated environment per project. Each workspace receives only the modules and credentials explicitly selected for that project.
+
+## Status
+
+This repository is in early implementation. The initial Go module, configuration loading, workspace manifest foundations, runtime detection, and minimal TUI shell are in place.
+
+See [PROJECT.md](PROJECT.md) for the implementation plan.
+
+## Planned Features
+
+- TUI application written in Go, with a minimal CLI for automation.
+- Linux and macOS support.
+- Docker and Podman support.
+- Global configuration for workspace root, runtime, base image, and module directories.
+- One long-lived container per workspace.
+- One generated image per workspace.
+- Host TUI attaches to the workspace container.
+- The workspace container runs a small entrypoint that starts `opencode` for the first session and `opencode -c` when sessions already exist.
+- Dedicated home directory per workspace.
+- Module-based configuration for packages, environment variables, config files, commands, skills, agents, and plugins.
+- Module hooks implemented as Go binaries, scripts, or other executables.
+- Main TUI actions to create, attach, edit, stop, delete, and update workspaces.
+- CLI commands limited to `list` and `attach`.
+
+## Concept
+
+```text
+Host machine
+  opencode-manager TUI
+Workspace container
+  opencode
+  Dedicated home directory
+  /home/debian/workspace
+  Selected tools
+  Selected credentials
+  Selected OpenCode commands, skills, agents, and plugins
+```
+
+## Workspace Model
+
+Each workspace has:
+
+- A name.
+- A dedicated directory under the configured workspace root.
+- A dedicated home directory.
+- A global `opencode.json` mounted read-only at `home/.config/opencode/opencode.json`.
+- Globally shared OpenCode commands, skills, agents, and plugins, mounted read-only.
+- Selected module configuration.
+- A generated image.
+- A long-lived container.
+- A long-lived attachable container that runs OpenCode interactively.
+
+Users can clone any needed repositories inside the workspace home directory.
+
+At the workspace root, only `workspace.yaml` and `home/` should be created. Environment values, image/package requirements, module state, and generated OpenCode paths are tracked through `workspace.yaml` and files under `home/`.
+
+## Module Model
+
+Modules are responsible for adding capabilities to a workspace.
+
+A module can provide:
+
+- Debian packages for the workspace image.
+- Environment variables.
+- Files written into the workspace home directory.
+- OpenCode config fragments.
+- OpenCode commands.
+- OpenCode skills.
+- OpenCode agents and plugins.
+- TUI prompts for required values.
+- Executable hooks for discovery, validation, generation, and updates.
+
+Example modules include `ssh`, `git`, `aws`, `kubernetes`, `github`, and `opencode`.
+
+## Configuration
+
+The global config file defines where workspaces are stored and which container runtime is used.
+
+Suggested location:
+
+```text
+~/.config/opencode-manager/config.yaml
+```
+
+Example:
+
+```yaml
+workspaceRoot: /home/user/.local/share/opencode-manager
+runtime: docker
+useLocalOpenCodeAuth: false
+baseImage:
+  name: debian:stable-slim
+  packages:
+    - htop
+    - unzip
+  commands:
+    - update-ca-certificates
+moduleDirs:
+  - /home/user/.config/opencode-manager/modules
+```
+
+`runtime` must be either `docker` or `podman`.
+
+Set `useLocalOpenCodeAuth: true` to mount the host file
+`~/.local/share/opencode/auth.json` read-write into the same path in each
+workspace container. The default `false` keeps auth isolated from the host.
+
+Generated workspace images always include `brew`, `npx`, `uvx`, `git`, `ripgrep`, and `jq`. Add project-specific extras with `baseImage.packages` and `baseImage.commands`.
+
+`opencode-manager` builds a managed base image from the `baseImage` definition and reuses it while that definition stays unchanged. Changing `baseImage.name`, `baseImage.packages`, or `baseImage.commands` produces a new managed base image tag.
+
+When the TUI starts, it ensures the managed base image exists and shows `Creating the base image...` while the image is being built.
+
+### Global OpenCode Templates
+
+OpenCode configuration is shared across all workspaces from the global config
+directory:
+
+```text
+~/.config/opencode-manager/
+├── AGENTS.md
+├── opencode.json
+├── agents/
+├── commands/
+├── plugins/
+└── skills/
+```
+
+These entries are **mounted read-only** into every workspace container at
+`/home/debian/.config/opencode/`. Editing a file on the host propagates live to
+all running workspaces — no copy is made and no recreation is needed. Adding or
+removing a template takes effect the next time a workspace container is
+(re)created.
+
+On startup, `opencode-manager` creates any missing entries (so the mounts always
+have a source):
+
+- `AGENTS.md` and the `agents/`, `commands/`, `plugins/`, `skills/` directories
+  are created empty.
+- `opencode.json`, which OpenCode requires to be non-empty, is seeded with a
+  minimal valid config:
+
+  ```json
+  {
+    "$schema": "https://opencode.ai/config.json"
+  }
+  ```
+
+Existing files are never overwritten, so your edits are preserved. Per-project
+overrides are still possible via an `opencode.json` in the workspace project
+directory.
+
+## Security Principle
+
+A workspace starts with no implicit host access.
+
+Every cloud credential, Kubernetes context, SSH key, token, config file, tool, command, skill, agent, or environment variable must be added by a selected module.
+
+Secrets may be stored as environment variables or plain text files inside the workspace when a module needs them.
+
+## Installation
+
+Install the npm package with:
+
+```sh
+npm install -g opencode-manager
+```
+
+The package ships prebuilt Linux and macOS binaries for x64 and arm64. During
+installation it creates the global `opencode-manager` config directory, writes a
+default `config.yaml` when one does not already exist, and copies bundled
+modules into the default `modules/` directory without overwriting existing
+entries.
+
+Docker or Podman must be installed separately on the host.
+
+## Development
+
+Run the current TUI shell with:
+
+```sh
+go run ./cmd/opencode-manager
+```
+
+Minimal CLI:
+
+```sh
+opencode-manager list
+opencode-manager attach <workspace>
+```
+
+The planned stack is:
+
+- Go
+- Bubble Tea
+- Bubbles
+- Lip Gloss
+- Docker CLI
+- Podman CLI
+
+See [PROJECT.md](PROJECT.md) for phases and architecture.

package/bin/opencode-manager

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+
+const { spawnSync } = require("node:child_process");
+const path = require("node:path");
+
+const supportedPlatforms = new Set(["darwin", "linux"]);
+const supportedArchitectures = new Set(["x64", "arm64"]);
+
+if (!supportedPlatforms.has(process.platform) || !supportedArchitectures.has(process.arch)) {
+  console.error(`opencode-manager does not ship a binary for ${process.platform}/${process.arch}.`);
+  process.exit(1);
+}
+
+const binary = path.join(__dirname, "..", "dist", `opencode-manager-${process.platform}-${process.arch}`);
+const result = spawnSync(binary, process.argv.slice(2), { stdio: "inherit" });
+
+if (result.error) {
+  console.error(`failed to run opencode-manager: ${result.error.message}`);
+  process.exit(1);
+}
+
+process.exit(result.status ?? 1);

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@mickaelroger78/opencode-manager",
+  "version": "0.1.0",
+  "description": "TUI for managing isolated OpenCode workspaces.",
+  "license": "MIT",
+  "bin": {
+    "opencode-manager": "bin/opencode-manager"
+  },
+  "scripts": {
+    "build": "go build -o dist/opencode-manager-$(node -p \"process.platform\")-$(node -p \"process.arch\") ./cmd/opencode-manager",
+    "test": "go test ./...",
+    "prepack": "node scripts/verify-package.js",
+    "postinstall": "node scripts/postinstall.js"
+  },
+  "files": [
+    "bin/",
+    "dist/",
+    "modules/",
+    "scripts/postinstall.js",
+    "scripts/verify-package.js"
+  ],
+  "os": [
+    "darwin",
+    "linux"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  }
+}

package/scripts/postinstall.js

@@ -0,0 +1,78 @@
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+
+const packageRoot = path.resolve(__dirname, "..");
+const managerDir = path.join(userConfigDir(), "opencode-manager");
+const modulesDir = path.join(managerDir, "modules");
+
+fs.mkdirSync(managerDir, { mode: 0o700, recursive: true });
+fs.mkdirSync(modulesDir, { mode: 0o700, recursive: true });
+
+ensureConfig();
+copyMissingEntries(path.join(packageRoot, "modules"), modulesDir);
+
+function userConfigDir() {
+  if (process.env.XDG_CONFIG_HOME) {
+    return process.env.XDG_CONFIG_HOME;
+  }
+  if (process.platform === "darwin") {
+    return path.join(os.homedir(), "Library", "Application Support");
+  }
+  return path.join(os.homedir(), ".config");
+}
+
+function ensureConfig() {
+  const configPath = path.join(managerDir, "config.yaml");
+  if (fs.existsSync(configPath)) {
+    return;
+  }
+
+  const workspaceRoot = path.join(os.homedir(), ".local", "share", "opencode-manager");
+  const config = [
+    `workspaceRoot: ${yamlString(workspaceRoot)}`,
+    "runtime: docker",
+    "useLocalOpenCodeAuth: false",
+    "baseImage:",
+    "  name: debian:stable-slim",
+    "  packages: []",
+    "  commands: []",
+    "moduleDirs:",
+    `  - ${yamlString(modulesDir)}`,
+    "",
+  ].join("\n");
+
+  fs.writeFileSync(configPath, config, { mode: 0o600 });
+}
+
+function copyMissingEntries(source, destination) {
+  if (!fs.existsSync(source)) {
+    return;
+  }
+
+  for (const entry of fs.readdirSync(source, { withFileTypes: true })) {
+    if (entry.name === ".gitkeep") {
+      continue;
+    }
+
+    const sourcePath = path.join(source, entry.name);
+    const destinationPath = path.join(destination, entry.name);
+
+    if (fs.existsSync(destinationPath)) {
+      continue;
+    }
+
+    if (entry.isDirectory()) {
+      fs.cpSync(sourcePath, destinationPath, { recursive: true, mode: fs.constants.COPYFILE_EXCL });
+      continue;
+    }
+
+    if (entry.isFile()) {
+      fs.copyFileSync(sourcePath, destinationPath, fs.constants.COPYFILE_EXCL);
+    }
+  }
+}
+
+function yamlString(value) {
+  return JSON.stringify(value);
+}

package/scripts/verify-package.js

@@ -0,0 +1,20 @@
+const fs = require("node:fs");
+const path = require("node:path");
+
+const packageRoot = path.resolve(__dirname, "..");
+const binaries = [
+  "opencode-manager-linux-x64",
+  "opencode-manager-linux-arm64",
+  "opencode-manager-darwin-x64",
+  "opencode-manager-darwin-arm64",
+];
+
+const missing = binaries.filter((binary) => !fs.existsSync(path.join(packageRoot, "dist", binary)));
+
+if (missing.length > 0) {
+  console.error("Cannot pack opencode-manager; missing prebuilt binaries:");
+  for (const binary of missing) {
+    console.error(`  dist/${binary}`);
+  }
+  process.exit(1);
+}