@vividcodeai/embeddedcowork 0.0.3 → 0.0.5

package/README.md

@@ -32,13 +32,13 @@
 You can run EmbeddedCowork directly without installing it:
 
 ```sh
-npx @vividcode/embedcowork --launch
+npx @vividcodeai/embeddedcowork --launch
 ```
 
 To list all CLI options:
 
 ```sh
-npx @vividcode/embedcowork --help
+npx @vividcodeai/embeddedcowork --help
 ```
 
 On startup, EmbeddedCowork prints two URLs:
@@ -48,11 +48,11 @@ On startup, EmbeddedCowork prints two URLs:
 
 ### Install Globally
 
-Or install it globally to use the `embedcowork` command:
+Or install it globally to use the `embeddedcowork` command:
 
 ```sh
-npm install -g @vividcode/embedcowork
-embedcowork --launch
+npm install -g @vividcodeai/embeddedcowork
+embeddedcowork --launch
 ```
 
 ### Install Locally (per-project)
@@ -60,11 +60,11 @@ embedcowork --launch
 If you prefer to install EmbeddedCowork into a project and run the local binary:
 
 ```sh
-npm install @vividcode/embedcowork
-npx embedcowork --launch
+npm install @vividcodeai/embeddedcowork
+npx embeddedcowork --launch
 ```
 
-(`npx embedcowork ...` will use `./node_modules/.bin/embedcowork` when present.)
+(`npx embeddedcowork ...` will use `./node_modules/.bin/embeddedcowork` when present.)
 
 ### Common Flags
 
@@ -81,16 +81,16 @@ You can configure the server using flags or environment variables:
 | `--tls-ca <path>` | `CLI_TLS_CA` | Optional CA chain/bundle (PEM) |
 | `--tlsSANs <list>` | `CLI_TLS_SANS` | Additional TLS SANs (comma-separated) |
 | `--host <addr>` | `CLI_HOST` | Interface to bind (default 127.0.0.1) |
-| `--workspace-root <path>` | `CLI_WORKSPACE_ROOT` | Restricts the root path where new workspaces can be opened. Git worktrees are created in `.embedcowork/worktrees` inside the project folder. |
+| `--workspace-root <path>` | `CLI_WORKSPACE_ROOT` | Restricts the root path where new workspaces can be opened. Git worktrees are created in `.embeddedcowork/worktrees` inside the project folder. |
 | `--unrestricted-root` | `CLI_UNRESTRICTED_ROOT` | Allow full-filesystem browsing |
 | `--config <path>` | `CLI_CONFIG` | Config file location |
 | `--launch` | `CLI_LAUNCH` | Open the UI in a Chromium-based browser |
 | `--log-level <level>` | `CLI_LOG_LEVEL` | Logging level (trace, debug, info, warn, error) |
 | `--log-destination <path>` | `CLI_LOG_DESTINATION` | Log destination file (defaults to stdout) |
-| `--username <username>` | `EMBEDCOWORK_SERVER_USERNAME` | Username for EmbeddedCowork's internal auth (default `embedcowork`) |
-| `--password <password>` | `EMBEDCOWORK_SERVER_PASSWORD` | Password for EmbeddedCowork's internal auth |
-| `--generate-token` | `EMBEDCOWORK_GENERATE_TOKEN` | Emit a one-time local bootstrap token for desktop flows |
-| `--dangerously-skip-auth` | `EMBEDCOWORK_SKIP_AUTH` | Disable EmbeddedCowork's internal auth (use only behind a trusted perimeter) |
+| `--username <username>` | `EMBEDDEDCOWORK_SERVER_USERNAME` | Username for EmbeddedCowork's internal auth (default `embeddedcowork`) |
+| `--password <password>` | `EMBEDDEDCOWORK_SERVER_PASSWORD` | Password for EmbeddedCowork's internal auth |
+| `--generate-token` | `EMBEDDEDCOWORK_GENERATE_TOKEN` | Emit a one-time local bootstrap token for desktop flows |
+| `--dangerously-skip-auth` | `EMBEDDEDCOWORK_SKIP_AUTH` | Disable EmbeddedCowork's internal auth (use only behind a trusted perimeter) |
 | `--ui-dir <path>` | `CLI_UI_DIR` | Directory containing the built UI bundle |
 | `--ui-dev-server <url>` | `CLI_UI_DEV_SERVER` | Proxy UI requests to a running dev server (requires `--https=false --http=true`) |
 | `--ui-no-update` | `CLI_UI_NO_UPDATE` | Disable remote UI updates |
@@ -102,15 +102,15 @@ You can configure the server using flags or environment variables:
 If you want the latest bleeding-edge builds (published as GitHub pre-releases), use the dev package:
 
 ```sh
-npx @vividcode/embedcowork-dev --launch
+npx @vividcodeai/embeddedcowork-dev --launch
 ```
 
 These environment variables control how EmbeddedCowork checks for dev updates:
 
 | Env Variable | Description |
 |-------------|-------------|
-| `EMBEDCOWORK_UPDATE_CHANNEL` | Update channel (use `dev` to enable dev build update checks) |
-| `EMBEDCOWORK_GITHUB_REPO` | GitHub repo used for dev release checks (default `VividCodeAI/EmbeddedCowork`) |
+| `EMBEDDEDCOWORK_UPDATE_CHANNEL` | Update channel (use `dev` to enable dev build update checks) |
+| `EMBEDDEDCOWORK_GITHUB_REPO` | GitHub repo used for dev release checks (default `VividCodeAI/EmbeddedCowork`) |
 
 ### HTTP vs HTTPS
 
@@ -118,13 +118,13 @@ These environment variables control how EmbeddedCowork checks for dev updates:
 - To run plain HTTP only (useful for development):
 
 ```sh
-embedcowork --https=false --http=true
+embeddedcowork --https=false --http=true
 ```
 
 - To run both HTTPS (for remote) and HTTP loopback (for desktop):
 
 ```sh
-embedcowork --https=true --http=true
+embeddedcowork --https=true --http=true
 ```
 
 ### Remote Access Binding Rules
@@ -139,19 +139,19 @@ embedcowork --https=true --http=true
 
 If `--https=true` and you do not provide `--tls-key/--tls-cert`, EmbeddedCowork generates a local certificate automatically under your config directory:
 
-- `~/.config/embedcowork/tls/ca-cert.pem`
-- `~/.config/embedcowork/tls/server-cert.pem`
+- `~/.config/embeddedcowork/tls/ca-cert.pem`
+- `~/.config/embeddedcowork/tls/server-cert.pem`
 
 Certificates are valid for about 30 days and rotate automatically on startup when needed. You can add extra SANs via:
 
 ```sh
-embedcowork --tlsSANs "localhost,127.0.0.1,my-hostname,192.168.1.10"
+embeddedcowork --tlsSANs "localhost,127.0.0.1,my-hostname,192.168.1.10"
 ```
 
 ### Authentication
 
 - Default behavior: EmbeddedCowork requires a login (username/password) and stores a session cookie in the browser.
-- `--dangerously-skip-auth` / `EMBEDCOWORK_SKIP_AUTH=true` disables the login prompt and treats all requests as authenticated.
+- `--dangerously-skip-auth` / `EMBEDDEDCOWORK_SKIP_AUTH=true` disables the login prompt and treats all requests as authenticated.
   Use this only when access is already protected by another layer (SSO proxy, VPN, Coder workspace auth, etc.).
   If you bind to `0.0.0.0` while skipping auth, anyone who can reach the port can access the API.
 
@@ -169,5 +169,5 @@ When running as a server EmbeddedCowork can also be installed as a PWA from any
 
 ### Data Storage
 
-- **Config**: `~/.config/embedcowork/config.json`
-- **Instance Data**: `~/.config/embedcowork/instances` (chat history, etc.)
+- **Config**: `~/.config/embeddedcowork/config.json`
+- **Instance Data**: `~/.config/embeddedcowork/instances` (chat history, etc.)

package/dist/auth/auth-store.js

@@ -68,7 +68,7 @@ export class AuthStore {
             this.logger.debug({ authFilePath: this.authFilePath }, "No auth file present; bootstrap-only mode enabled");
             return;
         }
-        throw new Error(`No server password configured. Create ${this.authFilePath} or start with --password / EMBEDCOWORK_SERVER_PASSWORD.`);
+        throw new Error(`No server password configured. Create ${this.authFilePath} or start with --password / EMBEDDEDCOWORK_SERVER_PASSWORD.`);
     }
     validateCredentials(username, password) {
         const auth = this.load();
@@ -82,7 +82,7 @@ export class AuthStore {
     }
     setPassword(params) {
         if (this.overrideAuth) {
-            throw new Error("Server password is provided via CLI/env and cannot be changed while running. Restart without --password / EMBEDCOWORK_SERVER_PASSWORD to use auth.json.");
+            throw new Error("Server password is provided via CLI/env and cannot be changed while running. Restart without --password / EMBEDDEDCOWORK_SERVER_PASSWORD to use auth.json.");
         }
         const current = this.load();
         if (!current) {

package/dist/auth/manager.js

@@ -3,9 +3,9 @@ import { AuthStore } from "./auth-store";
 import { TokenManager } from "./token-manager";
 import { SessionManager } from "./session-manager";
 import { isLoopbackAddress, parseCookies } from "./http-auth";
-export const BOOTSTRAP_TOKEN_STDOUT_PREFIX = "EMBEDCOWORK_BOOTSTRAP_TOKEN:";
-export const DEFAULT_AUTH_USERNAME = "embedcowork";
-export const DEFAULT_AUTH_COOKIE_NAME = "embedcowork_session";
+export const BOOTSTRAP_TOKEN_STDOUT_PREFIX = "EMBEDDEDCOWORK_BOOTSTRAP_TOKEN:";
+export const DEFAULT_AUTH_USERNAME = "embeddedcowork";
+export const DEFAULT_AUTH_COOKIE_NAME = "embeddedcowork_session";
 export class AuthManager {
     constructor(init, logger) {
         this.init = init;

package/dist/background-processes/manager.js

@@ -2,7 +2,7 @@ import { spawn, spawnSync } from "child_process";
 import { createWriteStream, existsSync, promises as fs } from "fs";
 import path from "path";
 import { randomBytes } from "crypto";
-const ROOT_DIR = ".embedcowork/background_processes";
+const ROOT_DIR = ".embeddedcowork/background_processes";
 const INDEX_FILE = "index.json";
 const OUTPUT_FILE = "output.txt";
 const STOP_TIMEOUT_MS = 2000;

package/dist/config/location.js

@@ -17,13 +17,13 @@ function isJsonPath(filePath) {
  * Resolve EmbeddedCowork's config location into a stable base directory + derived file paths.
  *
  * Supported inputs:
- * - Directory: "~/.config/embedcowork"
- * - YAML file: "~/.config/embedcowork/config.yaml" (or any *.yml/*.yaml)
- * - Legacy JSON file: "~/.config/embedcowork/config.json"
+ * - Directory: "~/.config/embeddedcowork"
+ * - YAML file: "~/.config/embeddedcowork/config.yaml" (or any *.yml/*.yaml)
+ * - Legacy JSON file: "~/.config/embeddedcowork/config.json"
  */
 export function resolveConfigLocation(raw) {
     const trimmed = (raw ?? "").trim();
-    const fallback = "~/.config/embedcowork/config.json";
+    const fallback = "~/.config/embeddedcowork/config.json";
     const input = trimmed.length > 0 ? trimmed : fallback;
     const resolvedInput = resolvePath(input);
     if (isYamlPath(resolvedInput)) {

package/dist/opencode-config/README.md

@@ -4,13 +4,13 @@
 Template config + plugins injected into every OpenCode instance that EmbeddedCowork launches. It provides an EmbeddedCowork bridge plugin for local event exchange between the CLI server and opencode.
 
 ## What it is
-A packaged config directory that EmbeddedCowork copies into `~/.config/embedcowork/opencode-config` for production builds or uses directly in dev. OpenCode autoloads any `plugin/*.ts` or `plugin/*.js` from this directory.
+A packaged config directory that EmbeddedCowork copies into `~/.config/embeddedcowork/opencode-config` for production builds or uses directly in dev. OpenCode autoloads any `plugin/*.ts` or `plugin/*.js` from this directory.
 
 ## How it works
 - EmbeddedCowork sets `OPENCODE_CONFIG_DIR` when spawning each opencode instance (`packages/server/src/workspaces/manager.ts`).
 - This template is synced from `packages/opencode-config` (`packages/server/src/opencode-config.ts`, `packages/server/scripts/copy-opencode-config.mjs`).
-- OpenCode autoloads plugins from `plugin/` (`packages/opencode-config/plugin/embedcowork.ts`).
-- The `EmbeddedCoworkPlugin` reads `EMBEDCOWORK_INSTANCE_ID` + `EMBEDCOWORK_BASE_URL`, connects to `GET /workspaces/:id/plugin/events`, and posts to `POST /workspaces/:id/plugin/event` (`packages/opencode-config/plugin/lib/client.ts`).
+- OpenCode autoloads plugins from `plugin/` (`packages/opencode-config/plugin/embeddedcowork.ts`).
+- The `EmbeddedCoworkPlugin` reads `EMBEDDEDCOWORK_INSTANCE_ID` + `EMBEDDEDCOWORK_BASE_URL`, connects to `GET /workspaces/:id/plugin/events`, and posts to `POST /workspaces/:id/plugin/event` (`packages/opencode-config/plugin/lib/client.ts`).
 - The server exposes the plugin routes and maps events into the UI SSE pipeline (`packages/server/src/server/routes/plugin.ts`, `packages/server/src/plugins/handlers.ts`).
 
 ## Expectations
@@ -25,7 +25,7 @@ A packaged config directory that EmbeddedCowork copies into `~/.config/embedcowo
 - Promote stable event shapes and version tags once the protocol settles.
 
 ## Pointers
-- Plugin entry: `packages/opencode-config/plugin/embedcowork.ts`
+- Plugin entry: `packages/opencode-config/plugin/embeddedcowork.ts`
 - Plugin client: `packages/opencode-config/plugin/lib/client.ts`
 - Plugin server routes: `packages/server/src/server/routes/plugin.ts`
 - Plugin event handling: `packages/server/src/plugins/handlers.ts`

package/dist/opencode-config/opencode.jsonc

@@ -1,3 +1,35 @@
 {
-  "$schema": "https://opencode.ai/config.json"
+  "$schema": "https://opencode.ai/config.json",
+   "mcp": {
+    "embedded-xLink-mcp": {
+      "type": "local",
+      "command": [
+        "npx",
+        "-y",
+        "@vividcodeai/embedded-xlink-mcp"
+      ],
+      "enabled": false,
+      "environment": {}
+    },
+	 "embedded-serial-mcp": {
+      "type": "local",
+      "command": [
+        "npx",
+        "-y",
+        "@vividcodeai/embedded-serial-mcp"
+      ],
+      "enabled": false,
+      "environment": {}
+    },
+    "embedded-gdb-mcp": {
+      "type": "local",
+      "command": [
+        "npx",
+        "-y",
+        "@vividcodeai/embedded-gdb-mcp"
+      ],
+      "enabled": false,
+      "environment": {}
+    },
+  },
 }

package/dist/opencode-config/plugin/{embedcowork.ts → embeddedcowork.ts}

@@ -10,9 +10,9 @@ export async function EmbeddedCoworkPlugin(input: PluginInput) {
   const backgroundProcessTools = createBackgroundProcessTools(config, { baseDir: input.directory })
 
   await client.startEvents((event) => {
-    if (event.type === "embedcowork.ping") {
+    if (event.type === "embeddedcowork.ping") {
       void client.postEvent({
-        type: "embedcowork.pong",
+        type: "embeddedcowork.pong",
         properties: {
           ts: Date.now(),
           pingTs: (event.properties as any)?.ts,
@@ -21,7 +21,7 @@ export async function EmbeddedCoworkPlugin(input: PluginInput) {
       return
     }
 
-    if (event.type === "embedcowork.voiceMode") {
+    if (event.type === "embeddedcowork.voiceMode") {
       voiceModeEnabled = Boolean((event.properties as { enabled?: unknown } | undefined)?.enabled)
     }
   })

package/dist/opencode-config/plugin/lib/request.ts

@@ -14,8 +14,8 @@ export type EmbeddedCoworkConfig = {
 
 export function getEmbeddedCoworkConfig(): EmbeddedCoworkConfig {
   return {
-    instanceId: requireEnv("EMBEDCOWORK_INSTANCE_ID"),
-    baseUrl: requireEnv("EMBEDCOWORK_BASE_URL"),
+    instanceId: requireEnv("EMBEDDEDCOWORK_INSTANCE_ID"),
+    baseUrl: requireEnv("EMBEDDEDCOWORK_BASE_URL"),
   }
 }
 

package/dist/opencode-config.js

@@ -3,7 +3,7 @@ import { createLogger } from "./logger";
 import { resolveOpencodeTemplateDir } from "./runtime-paths";
 const log = createLogger({ component: "opencode-config" });
 const templateDir = resolveOpencodeTemplateDir(import.meta.url);
-const isDevBuild = Boolean(process.env.EMBEDCOWORK_DEV ?? process.env.CLI_UI_DEV_SERVER);
+const isDevBuild = Boolean(process.env.EMBEDDEDCOWORK_DEV ?? process.env.CLI_UI_DEV_SERVER);
 export function getOpencodeConfigDir() {
     if (!existsSync(templateDir)) {
         throw new Error(`EmbeddedCowork Opencode config template missing at ${templateDir}`);

package/dist/plugins/handlers.js

@@ -1,6 +1,6 @@
 export function handlePluginEvent(workspaceId, event, deps) {
     switch (event.type) {
-        case "embedcowork.pong":
+        case "embeddedcowork.pong":
             deps.logger.debug({ workspaceId, properties: event.properties }, "Plugin pong received");
             return;
         default:
@@ -9,7 +9,7 @@ export function handlePluginEvent(workspaceId, event, deps) {
 }
 export function buildPingEvent() {
     return {
-        type: "embedcowork.ping",
+        type: "embeddedcowork.ping",
         properties: {
             ts: Date.now(),
         },

package/dist/plugins/voice-mode.js

@@ -66,7 +66,7 @@ export class VoiceModeManager {
 }
 function buildVoiceModeEvent(enabled) {
     return {
-        type: "embedcowork.voiceMode",
+        type: "embeddedcowork.voiceMode",
         properties: {
             enabled,
             formatVersion: "v1",

package/dist/runtime-paths.js

@@ -24,7 +24,7 @@ export function getPackagedDistDir() {
 }
 export function resolveServerPackageRoot(importMetaUrl) {
     const moduleDir = safeModuleDir(importMetaUrl);
-    const configuredRoot = process.env.EMBEDCOWORK_SERVER_ROOT?.trim();
+    const configuredRoot = process.env.EMBEDDEDCOWORK_SERVER_ROOT?.trim();
     const candidates = [
         configuredRoot ? path.resolve(configuredRoot) : null,
         moduleDir ? path.resolve(moduleDir, "..") : null,

package/dist/server/__tests__/remote-proxy.test.js

@@ -7,7 +7,7 @@ import path from "node:path";
 import { Agent, fetch } from "undici";
 import { RemoteProxySessionManager } from "../remote-proxy";
 import { resolveHttpsOptions } from "../tls";
-const sharedTempDir = fs.mkdtempSync(path.join(os.tmpdir(), "embedcowork-remote-proxy-test-"));
+const sharedTempDir = fs.mkdtempSync(path.join(os.tmpdir(), "embeddedcowork-remote-proxy-test-"));
 const sharedTls = resolveHttpsOptions({
     enabled: true,
     configDir: sharedTempDir,
@@ -38,7 +38,7 @@ describe("RemoteProxySessionManager", () => {
             const session2 = await createSession(manager, `${upstreamBaseUrl}/base`);
             const blocked = await proxyFetch(`${session1.proxyOrigin}/status`);
             assert.equal(blocked.status, 403);
-            const wrongTokenResponse = await proxyFetch(`${session1.proxyOrigin}/__embedcowork/api/auth/token`, {
+            const wrongTokenResponse = await proxyFetch(`${session1.proxyOrigin}/__embeddedcowork/api/auth/token`, {
                 method: "POST",
                 headers: { "content-type": "application/json" },
                 body: JSON.stringify({ token: session2.token }),
@@ -148,7 +148,7 @@ async function createSession(manager, baseUrl) {
     };
 }
 async function activateSession(session) {
-    const response = await proxyFetch(`${session.proxyOrigin}/__embedcowork/api/auth/token`, {
+    const response = await proxyFetch(`${session.proxyOrigin}/__embeddedcowork/api/auth/token`, {
         method: "POST",
         headers: { "content-type": "application/json" },
         body: JSON.stringify({ token: session.token }),

package/dist/server/remote-proxy.js

@@ -4,8 +4,8 @@ import { Readable } from "stream";
 import { pipeline } from "stream/promises";
 import { Agent, fetch } from "undici";
 const LOOPBACK_HOST = "127.0.0.1";
-const BOOTSTRAP_PAGE_PATH = "/__embedcowork/auth/token";
-const BOOTSTRAP_EXCHANGE_PATH = "/__embedcowork/api/auth/token";
+const BOOTSTRAP_PAGE_PATH = "/__embeddedcowork/auth/token";
+const BOOTSTRAP_EXCHANGE_PATH = "/__embeddedcowork/api/auth/token";
 const SESSION_IDLE_TTL_MS = 30 * 60000;
 export class RemoteProxySessionManager {
     constructor(options) {

package/dist/server/routes/events.js

@@ -30,7 +30,7 @@ export function registerEventRoutes(app, deps) {
         const unsubscribe = deps.eventBus.onEvent(send);
         const heartbeat = setInterval(() => {
             const ping = { ts: Date.now() };
-            reply.raw.write(`event: embedcowork.client.ping\ndata: ${JSON.stringify(ping)}\n\n`);
+            reply.raw.write(`event: embeddedcowork.client.ping\ndata: ${JSON.stringify(ping)}\n\n`);
         }, 15000);
         let closed = false;
         const close = () => {

package/dist/storage/instance-store.js

@@ -7,7 +7,7 @@ const DEFAULT_INSTANCE_DATA = {
     agentModelSelections: {},
 };
 export class InstanceStore {
-    constructor(baseDir = path.join(os.homedir(), ".config", "embedcowork", "instances")) {
+    constructor(baseDir = path.join(os.homedir(), ".config", "embeddedcowork", "instances")) {
         this.instancesDir = baseDir;
         fs.mkdirSync(this.instancesDir, { recursive: true });
     }

package/dist/ui/__tests__/remote-ui.test.js

@@ -16,7 +16,7 @@ const noopLogger = {
 };
 let tempRoot;
 beforeEach(() => {
-    tempRoot = mkdtempSync(path.join(os.tmpdir(), "embedcowork-ui-test-"));
+    tempRoot = mkdtempSync(path.join(os.tmpdir(), "embeddedcowork-ui-test-"));
 });
 afterEach(() => {
     rmSync(tempRoot, { recursive: true, force: true });

package/dist/ui/remote-ui.js

@@ -6,7 +6,7 @@ import path from "path";
 import { Readable } from "stream";
 import { fetch } from "undici";
 import yauzl from "yauzl";
-const DEFAULT_MANIFEST_URL = "https://ui.embedcowork.vividcode.ai/version.json";
+const DEFAULT_MANIFEST_URL = "https://ui.embeddedcowork.vividcode.ai/version.json";
 const MANIFEST_TIMEOUT_MS = 5000;
 const ZIP_TIMEOUT_MS = 30000;
 export async function resolveUi(options) {
@@ -139,7 +139,7 @@ function resolveUiCacheRoot(configDir) {
     if (configDir) {
         return path.join(configDir, "ui");
     }
-    return path.join(os.homedir(), ".config", "embedcowork", "ui");
+    return path.join(os.homedir(), ".config", "embeddedcowork", "ui");
 }
 async function resolveFromCacheOrBundled(args) {
     const bestLocal = await pickBestLocalUi({

package/dist/workspaces/__tests__/spawn.test.js

@@ -35,10 +35,10 @@ describe("buildWindowsSpawnSpec", () => {
             cwd: String.raw `\\wsl.localhost\Ubuntu\home\dev\workspace`,
             env: {
                 OPENCODE_CONFIG_DIR: String.raw `C:\Users\dev\AppData\Roaming\EmbeddedCowork\opencode-config`,
-                EMBEDCOWORK_INSTANCE_ID: "workspace-123",
+                EMBEDDEDCOWORK_INSTANCE_ID: "workspace-123",
                 OPENCODE_SERVER_PASSWORD: "secret",
             },
-            propagateEnvKeys: ["OPENCODE_CONFIG_DIR", "EMBEDCOWORK_INSTANCE_ID", "OPENCODE_SERVER_PASSWORD"],
+            propagateEnvKeys: ["OPENCODE_CONFIG_DIR", "EMBEDDEDCOWORK_INSTANCE_ID", "OPENCODE_SERVER_PASSWORD"],
         });
         assert.equal(spec.command, "wsl.exe");
         assert.deepEqual(spec.args, [
@@ -53,17 +53,17 @@ describe("buildWindowsSpawnSpec", () => {
             "0",
         ]);
         assert.equal(spec.cwd, undefined);
-        assert.equal(spec.env?.WSLENV, "OPENCODE_CONFIG_DIR/p:EMBEDCOWORK_INSTANCE_ID:OPENCODE_SERVER_PASSWORD");
+        assert.equal(spec.env?.WSLENV, "OPENCODE_CONFIG_DIR/p:EMBEDDEDCOWORK_INSTANCE_ID:OPENCODE_SERVER_PASSWORD");
     });
     it("upgrades existing WSLENV path entries to include /p", () => {
         const spec = buildWindowsSpawnSpec(String.raw `\\wsl.localhost\Ubuntu\home\dev\.opencode\bin\opencode`, ["serve"], {
             env: {
                 OPENCODE_CONFIG_DIR: String.raw `C:\Users\dev\AppData\Roaming\EmbeddedCowork\opencode-config`,
-                WSLENV: "OPENCODE_CONFIG_DIR:EMBEDCOWORK_INSTANCE_ID/u",
+                WSLENV: "OPENCODE_CONFIG_DIR:EMBEDDEDCOWORK_INSTANCE_ID/u",
             },
-            propagateEnvKeys: ["OPENCODE_CONFIG_DIR", "EMBEDCOWORK_INSTANCE_ID"],
+            propagateEnvKeys: ["OPENCODE_CONFIG_DIR", "EMBEDDEDCOWORK_INSTANCE_ID"],
         });
-        assert.equal(spec.env?.WSLENV, "OPENCODE_CONFIG_DIR/p:EMBEDCOWORK_INSTANCE_ID/u");
+        assert.equal(spec.env?.WSLENV, "OPENCODE_CONFIG_DIR/p:EMBEDDEDCOWORK_INSTANCE_ID/u");
     });
     it("propagates inherited known path variables even when they are not explicitly requested", () => {
         const spec = buildWindowsSpawnSpec(String.raw `\\wsl.localhost\Ubuntu\home\dev\.opencode\bin\opencode`, ["serve"], {
@@ -85,7 +85,7 @@ describe("buildWindowsSpawnSpec", () => {
             "sh",
             "-lc",
             'cd "$(wslpath -au "$1")" && shift && exec "$@"',
-            "embedcowork-wsl-launch",
+            "embeddedcowork-wsl-launch",
             String.raw `C:\Users\dev\workspace`,
             "/home/dev/.opencode/bin/opencode",
             "serve",
@@ -105,7 +105,7 @@ describe("buildWindowsSpawnSpec", () => {
             "sh",
             "-lc",
             'cd "$(wslpath -au "$1")" && shift && exec "$@"',
-            "embedcowork-wsl-launch",
+            "embeddedcowork-wsl-launch",
             String.raw `\\server\share\workspace`,
             "/home/dev/.opencode/bin/opencode",
             "serve",
@@ -114,7 +114,7 @@ describe("buildWindowsSpawnSpec", () => {
     it("can wrap WSL launches to emit the Linux PID marker", () => {
         const spec = buildWindowsSpawnSpec(String.raw `\\wsl.localhost\Ubuntu\home\dev\.opencode\bin\opencode`, ["serve"], {
             cwd: String.raw `\\wsl.localhost\Ubuntu\home\dev\workspace`,
-            wslPidMarker: "__EMBEDCOWORK_WSL_PID__:",
+            wslPidMarker: "__EMBEDDEDCOWORK_WSL_PID__:",
         });
         assert.equal(spec.command, "wsl.exe");
         assert.deepEqual(spec.args, [
@@ -123,13 +123,13 @@ describe("buildWindowsSpawnSpec", () => {
             "--exec",
             "sh",
             "-lc",
-            `printf '%s%s\\n' '__EMBEDCOWORK_WSL_PID__:' "$$" && cd "$1" && shift && exec "$@"`,
-            "embedcowork-wsl-launch",
+            `printf '%s%s\\n' '__EMBEDDEDCOWORK_WSL_PID__:' "$$" && cd "$1" && shift && exec "$@"`,
+            "embeddedcowork-wsl-launch",
             "/home/dev/workspace",
             "/home/dev/.opencode/bin/opencode",
             "serve",
         ]);
-        assert.equal(spec.wsl?.pidMarker, "__EMBEDCOWORK_WSL_PID__:");
+        assert.equal(spec.wsl?.pidMarker, "__EMBEDDEDCOWORK_WSL_PID__:");
     });
     it("builds the WSL kill command for tracked Linux PIDs", () => {
         const spec = buildWslSignalSpec("Ubuntu", 4321, "SIGTERM");

package/dist/workspaces/git-worktrees.js

@@ -163,7 +163,7 @@ export async function createManagedWorktree(params) {
             .replace(/^-+|-+$/g, "");
         return normalized || "worktree";
     };
-    const worktreesDir = path.join(repoRoot, ".embedcowork", "worktrees");
+    const worktreesDir = path.join(repoRoot, ".embeddedcowork", "worktrees");
     const targetDir = path.join(worktreesDir, sanitizeDirName(branch));
     await fsp.mkdir(worktreesDir, { recursive: true });
     try {

package/dist/workspaces/manager.js

@@ -139,8 +139,8 @@ export class WorkspaceManager {
         const environment = {
             ...userEnvironment,
             OPENCODE_CONFIG_DIR: this.opencodeConfigDir,
-            EMBEDCOWORK_INSTANCE_ID: id,
-            EMBEDCOWORK_BASE_URL: this.options.getServerBaseUrl(),
+            EMBEDDEDCOWORK_INSTANCE_ID: id,
+            EMBEDDEDCOWORK_BASE_URL: this.options.getServerBaseUrl(),
             ...(this.options.nodeExtraCaCertsPath ? { NODE_EXTRA_CA_CERTS: this.options.nodeExtraCaCertsPath } : {}),
             [OPENCODE_SERVER_USERNAME_ENV]: opencodeUsername,
             [OPENCODE_SERVER_PASSWORD_ENV]: opencodePassword,

package/dist/workspaces/opencode-auth.js

@@ -1,7 +1,7 @@
 import crypto from "node:crypto";
 export const OPENCODE_SERVER_USERNAME_ENV = "OPENCODE_SERVER_USERNAME";
 export const OPENCODE_SERVER_PASSWORD_ENV = "OPENCODE_SERVER_PASSWORD";
-export const DEFAULT_OPENCODE_USERNAME = "embedcowork";
+export const DEFAULT_OPENCODE_USERNAME = "embeddedcowork";
 export function generateOpencodeServerPassword() {
     return crypto.randomBytes(32).toString("base64url");
 }

package/dist/workspaces/runtime.js

@@ -3,7 +3,7 @@ import { existsSync, statSync } from "fs";
 import path from "path";
 import { buildSpawnSpec, buildWslSignalSpec } from "./spawn";
 const SENSITIVE_ENV_KEY = /(PASSWORD|TOKEN|SECRET)/i;
-const WSL_PID_MARKER = "__EMBEDCOWORK_WSL_PID__:";
+const WSL_PID_MARKER = "__EMBEDDEDCOWORK_WSL_PID__:";
 function redactEnvironment(env) {
     const redacted = {};
     for (const [key, value] of Object.entries(env)) {

package/dist/workspaces/spawn.js

@@ -139,7 +139,7 @@ function buildWslSpawnSpec(wslPath, args, options) {
     }
     if (shouldWrapWithShell) {
         const launchScript = buildWslLaunchScript(workingDirectory ?? undefined, options.wslPidMarker);
-        wslArgs.push("--exec", "sh", "-lc", launchScript, "embedcowork-wsl-launch");
+        wslArgs.push("--exec", "sh", "-lc", launchScript, "embeddedcowork-wsl-launch");
         if (workingDirectory) {
             wslArgs.push(workingDirectory.path);
         }

package/dist/workspaces/worktree-map.js

@@ -8,7 +8,7 @@ const DEFAULT_MAP = {
     parentSessionWorktreeSlug: {},
 };
 function getMapPath(repoRoot) {
-    return path.join(repoRoot, ".embedcowork", "worktreeMap.json");
+    return path.join(repoRoot, ".embeddedcowork", "worktreeMap.json");
 }
 function getGitExcludePath(repoRoot) {
     return path.join(repoRoot, ".git", "info", "exclude");
@@ -22,8 +22,8 @@ async function ensureGitExclude(repoRoot, logger) {
         return;
     }
     const entries = [
-        ".embedcowork/worktrees/",
-        ".embedcowork/worktreeMap.json",
+        ".embeddedcowork/worktrees/",
+        ".embeddedcowork/worktreeMap.json",
     ];
     let existing = "";
     try {
@@ -42,7 +42,7 @@ async function ensureGitExclude(repoRoot, logger) {
     if (missing.length === 0) {
         return;
     }
-    const header = existing.includes("# embedcowork") ? "" : (existing.trim() ? "\n" : "") + "# embedcowork\n";
+    const header = existing.includes("# embeddedcowork") ? "" : (existing.trim() ? "\n" : "") + "# embeddedcowork\n";
     const suffix = missing.map((e) => `${e}\n`).join("");
     await fsp.writeFile(excludePath, `${existing}${header}${suffix}`, "utf-8");
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vividcodeai/embeddedcowork",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "EmbeddedCowork Server",
   "license": "MIT",
   "author": {
@@ -27,7 +27,7 @@
     "build:ui": "npm run build --prefix ../ui",
     "prepare-ui": "node ./scripts/copy-ui-dist.mjs",
     "prepare-config": "node ./scripts/copy-opencode-config.mjs",
-    "dev": "cross-env EMBEDCOWORK_DEV=1 EMBEDCOWORK_SERVER_PASSWORD=embedcowork-dev CLI_UI_DEV_SERVER=http://localhost:3000 CLI_HTTPS=false CLI_HTTP=true tsx src/index.ts",
+    "dev": "cross-env EMBEDDEDCOWORK_DEV=1 EMBEDDEDCOWORK_SERVER_PASSWORD=embeddedcowork-dev CLI_UI_DEV_SERVER=http://localhost:3000 CLI_HTTPS=false CLI_HTTP=true tsx src/index.ts",
     "typecheck": "tsc --noEmit -p tsconfig.json"
   },
   "dependencies": {