@neuralnomads/codenomad 0.9.4 → 0.10.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (41) hide show
  1. package/README.md +60 -1
  2. package/dist/auth/manager.js +9 -0
  3. package/dist/config/schema.js +1 -0
  4. package/dist/index.js +156 -27
  5. package/dist/opencode-config/package.json +2 -2
  6. package/dist/server/http-server.js +171 -27
  7. package/dist/server/network-addresses.js +72 -0
  8. package/dist/server/routes/auth.js +10 -4
  9. package/dist/server/routes/meta.js +23 -76
  10. package/dist/server/routes/worktrees.js +156 -0
  11. package/dist/server/tls.js +224 -0
  12. package/dist/workspaces/git-worktrees.js +199 -0
  13. package/dist/workspaces/instance-events.js +22 -2
  14. package/dist/workspaces/manager.js +2 -1
  15. package/dist/workspaces/worktree-map.js +116 -0
  16. package/package.json +4 -2
  17. package/public/apple-touch-icon-180x180.png +0 -0
  18. package/public/assets/core-DlQNAQKj.js +1 -0
  19. package/public/assets/index-BKijAOjE.js +1 -0
  20. package/public/assets/index-BrQt8BRm.js +1 -0
  21. package/public/assets/index-CcwbbFk8.js +1 -0
  22. package/public/assets/index-CqF9c3PC.css +1 -0
  23. package/public/assets/{loading-BwDYSAEd.js → loading-DhYlTYtL.js} +1 -1
  24. package/public/assets/main-B7bETKAy.js +184 -0
  25. package/public/favicon.ico +0 -0
  26. package/public/index.html +7 -4
  27. package/public/loading.html +7 -4
  28. package/public/logo.png +0 -0
  29. package/public/manifest.webmanifest +1 -0
  30. package/public/maskable-icon-512x512.png +0 -0
  31. package/public/pwa-192x192.png +0 -0
  32. package/public/pwa-512x512.png +0 -0
  33. package/public/pwa-64x64.png +0 -0
  34. package/public/registerSW.js +1 -0
  35. package/public/sw.js +1 -0
  36. package/public/ui-version.json +1 -1
  37. package/public/workbox-60d14903.js +1 -0
  38. package/public/assets/index-C7GIedAD.js +0 -1
  39. package/public/assets/index-DAv6RUOV.css +0 -1
  40. package/public/assets/index-DPFZXALm.js +0 -1
  41. package/public/assets/main-CPMBg7Qb.js +0 -184
@@ -0,0 +1,156 @@
1
+ import { z } from "zod";
2
+ import { resolveRepoRoot, listWorktrees, isValidWorktreeSlug, createManagedWorktree, removeWorktree, } from "../../workspaces/git-worktrees";
3
+ import { ensureCodenomadGitExclude, readWorktreeMap, writeWorktreeMap } from "../../workspaces/worktree-map";
4
+ const WorktreeMapSchema = z.object({
5
+ version: z.literal(1),
6
+ defaultWorktreeSlug: z.string().min(1).default("root"),
7
+ parentSessionWorktreeSlug: z.record(z.string(), z.string()).default({}),
8
+ });
9
+ const WorktreeCreateSchema = z.object({
10
+ slug: z.string().trim().min(1),
11
+ branch: z.string().trim().min(1).optional(),
12
+ });
13
+ export function registerWorktreeRoutes(app, deps) {
14
+ app.get("/api/workspaces/:id/worktrees", async (request, reply) => {
15
+ const workspace = deps.workspaceManager.get(request.params.id);
16
+ if (!workspace) {
17
+ reply.code(404);
18
+ return { error: "Workspace not found" };
19
+ }
20
+ const { repoRoot, isGitRepo } = await resolveRepoRoot(workspace.path, request.log);
21
+ const worktrees = await listWorktrees({ repoRoot, workspaceFolder: workspace.path, logger: request.log });
22
+ const response = { worktrees, isGitRepo };
23
+ return response;
24
+ });
25
+ app.post("/api/workspaces/:id/worktrees", async (request, reply) => {
26
+ const workspace = deps.workspaceManager.get(request.params.id);
27
+ if (!workspace) {
28
+ reply.code(404);
29
+ return { error: "Workspace not found" };
30
+ }
31
+ try {
32
+ const body = WorktreeCreateSchema.parse(request.body ?? {});
33
+ const slug = body.slug;
34
+ if (!isValidWorktreeSlug(slug) || slug === "root") {
35
+ reply.code(400);
36
+ return { error: "Invalid worktree slug" };
37
+ }
38
+ if (body.branch) {
39
+ if (!isValidWorktreeSlug(body.branch) || body.branch === "root") {
40
+ reply.code(400);
41
+ return { error: "Invalid worktree branch" };
42
+ }
43
+ if (body.branch !== slug) {
44
+ reply.code(400);
45
+ return { error: "Branch must match slug" };
46
+ }
47
+ }
48
+ const { repoRoot, isGitRepo } = await resolveRepoRoot(workspace.path, request.log);
49
+ if (!isGitRepo) {
50
+ reply.code(400);
51
+ return { error: "Workspace is not a Git repository" };
52
+ }
53
+ await ensureCodenomadGitExclude(workspace.path, request.log).catch(() => undefined);
54
+ const created = await createManagedWorktree({
55
+ repoRoot,
56
+ workspaceFolder: workspace.path,
57
+ slug,
58
+ logger: request.log,
59
+ });
60
+ reply.code(201);
61
+ return created;
62
+ }
63
+ catch (error) {
64
+ return handleError(error, reply);
65
+ }
66
+ });
67
+ app.delete("/api/workspaces/:id/worktrees/:slug", async (request, reply) => {
68
+ const workspace = deps.workspaceManager.get(request.params.id);
69
+ if (!workspace) {
70
+ reply.code(404);
71
+ return { error: "Workspace not found" };
72
+ }
73
+ const slug = (request.params.slug ?? "").trim();
74
+ if (!isValidWorktreeSlug(slug) || slug === "root") {
75
+ reply.code(400);
76
+ return { error: "Invalid worktree slug" };
77
+ }
78
+ const { repoRoot, isGitRepo } = await resolveRepoRoot(workspace.path, request.log);
79
+ if (!isGitRepo) {
80
+ reply.code(400);
81
+ return { error: "Workspace is not a Git repository" };
82
+ }
83
+ const force = (request.query?.force ?? "").toString().toLowerCase() === "true";
84
+ try {
85
+ const worktrees = await listWorktrees({ repoRoot, workspaceFolder: workspace.path, logger: request.log });
86
+ const match = worktrees.find((wt) => wt.slug === slug);
87
+ if (!match || match.kind === "root") {
88
+ reply.code(404);
89
+ return { error: "Worktree not found" };
90
+ }
91
+ await removeWorktree({ workspaceFolder: workspace.path, directory: match.directory, force, logger: request.log });
92
+ // Best-effort: prune any mappings that point at the deleted worktree.
93
+ const current = await readWorktreeMap(workspace.path, request.log);
94
+ let changed = false;
95
+ const nextMapping = { ...(current.parentSessionWorktreeSlug ?? {}) };
96
+ for (const [sessionId, mapped] of Object.entries(nextMapping)) {
97
+ if (mapped === slug) {
98
+ delete nextMapping[sessionId];
99
+ changed = true;
100
+ }
101
+ }
102
+ const nextDefault = current.defaultWorktreeSlug === slug ? "root" : current.defaultWorktreeSlug;
103
+ if (nextDefault !== current.defaultWorktreeSlug) {
104
+ changed = true;
105
+ }
106
+ if (changed) {
107
+ await writeWorktreeMap(workspace.path, {
108
+ version: 1,
109
+ defaultWorktreeSlug: nextDefault,
110
+ parentSessionWorktreeSlug: nextMapping,
111
+ }, request.log);
112
+ }
113
+ reply.code(204);
114
+ }
115
+ catch (error) {
116
+ return handleError(error, reply);
117
+ }
118
+ });
119
+ app.get("/api/workspaces/:id/worktrees/map", async (request, reply) => {
120
+ const workspace = deps.workspaceManager.get(request.params.id);
121
+ if (!workspace) {
122
+ reply.code(404);
123
+ return { error: "Workspace not found" };
124
+ }
125
+ return await readWorktreeMap(workspace.path, request.log);
126
+ });
127
+ app.put("/api/workspaces/:id/worktrees/map", async (request, reply) => {
128
+ const workspace = deps.workspaceManager.get(request.params.id);
129
+ if (!workspace) {
130
+ reply.code(404);
131
+ return { error: "Workspace not found" };
132
+ }
133
+ try {
134
+ const parsed = WorktreeMapSchema.parse(request.body ?? {});
135
+ if (!isValidWorktreeSlug(parsed.defaultWorktreeSlug)) {
136
+ reply.code(400);
137
+ return { error: "Invalid defaultWorktreeSlug" };
138
+ }
139
+ for (const slug of Object.values(parsed.parentSessionWorktreeSlug ?? {})) {
140
+ if (!isValidWorktreeSlug(slug)) {
141
+ reply.code(400);
142
+ return { error: "Invalid worktree slug in mapping" };
143
+ }
144
+ }
145
+ await writeWorktreeMap(workspace.path, parsed, request.log);
146
+ reply.code(204);
147
+ }
148
+ catch (error) {
149
+ return handleError(error, reply);
150
+ }
151
+ });
152
+ }
153
+ function handleError(error, reply) {
154
+ reply.code(400);
155
+ return { error: error instanceof Error ? error.message : "Unable to fulfill request" };
156
+ }
@@ -0,0 +1,224 @@
1
+ import crypto from "crypto";
2
+ import fs from "fs";
3
+ import path from "path";
4
+ import { createRequire } from "module";
5
+ const require = createRequire(import.meta.url);
6
+ function loadForge() {
7
+ // node-forge is CJS in many installs; require keeps this compatible with our ESM output.
8
+ return require("node-forge");
9
+ }
10
+ const LEAF_VALIDITY_DAYS = 30;
11
+ const ROTATE_IF_EXPIRES_WITHIN_DAYS = 3;
12
+ const CA_VALIDITY_DAYS = 365;
13
+ export function resolveHttpsOptions(args) {
14
+ if (!args.enabled) {
15
+ return null;
16
+ }
17
+ const hasProvided = Boolean(args.tlsKeyPath && args.tlsCertPath);
18
+ if (hasProvided) {
19
+ const key = fs.readFileSync(args.tlsKeyPath, "utf-8");
20
+ const cert = fs.readFileSync(args.tlsCertPath, "utf-8");
21
+ const ca = args.tlsCaPath ? fs.readFileSync(args.tlsCaPath, "utf-8") : undefined;
22
+ return {
23
+ httpsOptions: { key, cert, ca },
24
+ caCertPath: args.tlsCaPath,
25
+ mode: "provided",
26
+ };
27
+ }
28
+ return ensureGeneratedTls(args);
29
+ }
30
+ function ensureGeneratedTls(args) {
31
+ const tlsDir = path.join(args.configDir, "tls");
32
+ const caKeyPath = path.join(tlsDir, "ca-key.pem");
33
+ const caCertPath = path.join(tlsDir, "ca-cert.pem");
34
+ const keyPath = path.join(tlsDir, "server-key.pem");
35
+ const certPath = path.join(tlsDir, "server-cert.pem");
36
+ fs.mkdirSync(tlsDir, { recursive: true });
37
+ const shouldRotateLeaf = () => {
38
+ try {
39
+ if (!fs.existsSync(certPath))
40
+ return true;
41
+ const pem = fs.readFileSync(certPath, "utf-8");
42
+ const x509 = new crypto.X509Certificate(pem);
43
+ const validToMs = Date.parse(x509.validTo);
44
+ if (!Number.isFinite(validToMs))
45
+ return true;
46
+ const rotateAt = validToMs - ROTATE_IF_EXPIRES_WITHIN_DAYS * 24 * 60 * 60 * 1000;
47
+ return Date.now() >= rotateAt;
48
+ }
49
+ catch {
50
+ return true;
51
+ }
52
+ };
53
+ const shouldRotateCa = () => {
54
+ try {
55
+ if (!fs.existsSync(caCertPath))
56
+ return true;
57
+ const pem = fs.readFileSync(caCertPath, "utf-8");
58
+ const x509 = new crypto.X509Certificate(pem);
59
+ const validToMs = Date.parse(x509.validTo);
60
+ if (!Number.isFinite(validToMs))
61
+ return true;
62
+ // CA rotates only when expired.
63
+ return Date.now() >= validToMs;
64
+ }
65
+ catch {
66
+ return true;
67
+ }
68
+ };
69
+ if (shouldRotateCa() || !fs.existsSync(caKeyPath)) {
70
+ const { caKeyPem, caCertPem } = generateCaCertificate();
71
+ writePemFile(caKeyPath, caKeyPem, 0o600);
72
+ writePemFile(caCertPath, caCertPem, 0o644);
73
+ args.logger.info({ caCertPath }, "Generated self-signed CodeNomad CA certificate");
74
+ }
75
+ if (shouldRotateLeaf() || !fs.existsSync(keyPath)) {
76
+ const caKeyPem = fs.readFileSync(caKeyPath, "utf-8");
77
+ const caCertPem = fs.readFileSync(caCertPath, "utf-8");
78
+ const { keyPem, certPem } = generateServerCertificate({
79
+ host: args.host,
80
+ tlsSANs: args.tlsSANs,
81
+ caKeyPem,
82
+ caCertPem,
83
+ });
84
+ writePemFile(keyPath, keyPem, 0o600);
85
+ writePemFile(certPath, certPem, 0o644);
86
+ args.logger.info({ certPath }, "Generated CodeNomad HTTPS certificate");
87
+ }
88
+ const key = fs.readFileSync(keyPath, "utf-8");
89
+ const cert = fs.readFileSync(certPath, "utf-8");
90
+ const ca = fs.readFileSync(caCertPath, "utf-8");
91
+ // Present the CA as part of the chain.
92
+ const chainedCert = `${cert.trim()}\n${ca.trim()}\n`;
93
+ return {
94
+ httpsOptions: {
95
+ key,
96
+ cert: chainedCert,
97
+ },
98
+ caCertPath,
99
+ mode: "generated",
100
+ };
101
+ }
102
+ function writePemFile(filePath, content, mode) {
103
+ fs.writeFileSync(filePath, content, { encoding: "utf-8", mode });
104
+ try {
105
+ fs.chmodSync(filePath, mode);
106
+ }
107
+ catch {
108
+ // best effort on platforms that ignore chmod
109
+ }
110
+ }
111
+ function generateCaCertificate() {
112
+ const forge = loadForge();
113
+ const keys = forge.pki.rsa.generateKeyPair(2048);
114
+ const cert = forge.pki.createCertificate();
115
+ cert.publicKey = keys.publicKey;
116
+ cert.serialNumber = crypto.randomBytes(16).toString("hex");
117
+ const now = new Date();
118
+ const notBefore = new Date(now.getTime() - 60000);
119
+ const notAfter = new Date(now.getTime() + CA_VALIDITY_DAYS * 24 * 60 * 60 * 1000);
120
+ cert.validity.notBefore = notBefore;
121
+ cert.validity.notAfter = notAfter;
122
+ const attrs = [{ name: "commonName", value: "CodeNomad Local CA" }];
123
+ cert.setSubject(attrs);
124
+ cert.setIssuer(attrs);
125
+ cert.setExtensions([
126
+ { name: "basicConstraints", cA: true },
127
+ { name: "keyUsage", keyCertSign: true, cRLSign: true, digitalSignature: true },
128
+ { name: "subjectKeyIdentifier" },
129
+ ]);
130
+ cert.sign(keys.privateKey, forge.md.sha256.create());
131
+ return {
132
+ caKeyPem: forge.pki.privateKeyToPem(keys.privateKey),
133
+ caCertPem: forge.pki.certificateToPem(cert),
134
+ };
135
+ }
136
+ function generateServerCertificate(args) {
137
+ const forge = loadForge();
138
+ const caKey = forge.pki.privateKeyFromPem(args.caKeyPem);
139
+ const caCert = forge.pki.certificateFromPem(args.caCertPem);
140
+ const keys = forge.pki.rsa.generateKeyPair(2048);
141
+ const cert = forge.pki.createCertificate();
142
+ cert.publicKey = keys.publicKey;
143
+ cert.serialNumber = crypto.randomBytes(16).toString("hex");
144
+ const now = new Date();
145
+ const notBefore = new Date(now.getTime() - 60000);
146
+ const notAfter = new Date(now.getTime() + LEAF_VALIDITY_DAYS * 24 * 60 * 60 * 1000);
147
+ cert.validity.notBefore = notBefore;
148
+ cert.validity.notAfter = notAfter;
149
+ const commonName = pickCommonName(args.host);
150
+ cert.setSubject([{ name: "commonName", value: commonName }]);
151
+ cert.setIssuer(caCert.subject.attributes);
152
+ const san = buildSubjectAltNames(args.host, args.tlsSANs);
153
+ cert.setExtensions([
154
+ { name: "basicConstraints", cA: false },
155
+ { name: "keyUsage", digitalSignature: true, keyEncipherment: true },
156
+ { name: "extKeyUsage", serverAuth: true },
157
+ { name: "subjectAltName", altNames: san },
158
+ { name: "subjectKeyIdentifier" },
159
+ ]);
160
+ cert.sign(caKey, forge.md.sha256.create());
161
+ return {
162
+ keyPem: forge.pki.privateKeyToPem(keys.privateKey),
163
+ certPem: forge.pki.certificateToPem(cert),
164
+ };
165
+ }
166
+ function pickCommonName(host) {
167
+ if (!host || host === "0.0.0.0") {
168
+ return "localhost";
169
+ }
170
+ if (host === "127.0.0.1") {
171
+ return "localhost";
172
+ }
173
+ return host;
174
+ }
175
+ function buildSubjectAltNames(host, tlsSANs) {
176
+ const dns = new Set();
177
+ const ips = new Set();
178
+ dns.add("localhost");
179
+ ips.add("127.0.0.1");
180
+ if (host && host !== "0.0.0.0") {
181
+ if (isIPv4(host)) {
182
+ ips.add(host);
183
+ }
184
+ else {
185
+ dns.add(host);
186
+ }
187
+ }
188
+ for (const token of splitList(tlsSANs)) {
189
+ if (isIPv4(token)) {
190
+ ips.add(token);
191
+ }
192
+ else if (token) {
193
+ dns.add(token);
194
+ }
195
+ }
196
+ const altNames = [];
197
+ // 2 = DNS, 7 = IP
198
+ for (const name of Array.from(dns)) {
199
+ altNames.push({ type: 2, value: name });
200
+ }
201
+ for (const ip of Array.from(ips)) {
202
+ altNames.push({ type: 7, ip });
203
+ }
204
+ return altNames;
205
+ }
206
+ function splitList(input) {
207
+ if (!input)
208
+ return [];
209
+ return input
210
+ .split(",")
211
+ .map((part) => part.trim())
212
+ .filter(Boolean);
213
+ }
214
+ function isIPv4(value) {
215
+ const parts = value.split(".");
216
+ if (parts.length !== 4)
217
+ return false;
218
+ return parts.every((part) => {
219
+ if (!/^[0-9]+$/.test(part))
220
+ return false;
221
+ const num = Number(part);
222
+ return Number.isInteger(num) && num >= 0 && num <= 255;
223
+ });
224
+ }
@@ -0,0 +1,199 @@
1
+ import path from "path";
2
+ import { spawn } from "child_process";
3
+ import { promises as fsp } from "fs";
4
+ function runGit(args, cwd) {
5
+ return new Promise((resolve) => {
6
+ const child = spawn("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
7
+ let stdout = "";
8
+ let stderr = "";
9
+ child.stdout?.on("data", (chunk) => {
10
+ stdout += chunk.toString();
11
+ });
12
+ child.stderr?.on("data", (chunk) => {
13
+ stderr += chunk.toString();
14
+ });
15
+ child.once("error", (error) => {
16
+ resolve({ ok: false, error, stdout, stderr });
17
+ });
18
+ child.once("close", (code) => {
19
+ if (code === 0) {
20
+ resolve({ ok: true, stdout });
21
+ }
22
+ else {
23
+ const error = new Error(stderr.trim() || `git ${args.join(" ")} failed with code ${code}`);
24
+ resolve({ ok: false, error, stdout, stderr });
25
+ }
26
+ });
27
+ });
28
+ }
29
+ export async function resolveRepoRoot(folder, logger) {
30
+ const result = await runGit(["rev-parse", "--show-toplevel"], folder);
31
+ if (!result.ok) {
32
+ logger?.debug?.({ folder, err: result.error }, "Folder is not a Git repository; using workspace folder as root");
33
+ return { repoRoot: folder, isGitRepo: false };
34
+ }
35
+ const repoRoot = result.stdout.trim();
36
+ if (!repoRoot) {
37
+ return { repoRoot: folder, isGitRepo: false };
38
+ }
39
+ return { repoRoot, isGitRepo: true };
40
+ }
41
+ function parseWorktreePorcelain(output) {
42
+ const records = [];
43
+ const lines = output.split(/\r?\n/);
44
+ let current = {};
45
+ const flush = () => {
46
+ if (current.worktree) {
47
+ records.push({ worktree: current.worktree, branch: current.branch });
48
+ }
49
+ current = {};
50
+ };
51
+ for (const line of lines) {
52
+ const trimmed = line.trim();
53
+ if (!trimmed) {
54
+ flush();
55
+ continue;
56
+ }
57
+ const [key, ...rest] = trimmed.split(" ");
58
+ const value = rest.join(" ").trim();
59
+ if (key === "worktree") {
60
+ current.worktree = value;
61
+ }
62
+ else if (key === "branch") {
63
+ // branch is like refs/heads/foo
64
+ current.branch = value.replace(/^refs\/heads\//, "");
65
+ }
66
+ else if (key === "HEAD") {
67
+ current.head = value;
68
+ }
69
+ else if (key === "detached") {
70
+ current.detached = true;
71
+ }
72
+ }
73
+ flush();
74
+ return records;
75
+ }
76
+ export async function listWorktrees(params) {
77
+ const { repoRoot, workspaceFolder, logger } = params;
78
+ const rootDescriptor = { slug: "root", directory: repoRoot, kind: "root" };
79
+ const result = await runGit(["worktree", "list", "--porcelain"], workspaceFolder);
80
+ if (!result.ok) {
81
+ logger?.debug?.({ repoRoot, err: result.error }, "Failed to list git worktrees; returning root only");
82
+ return [rootDescriptor];
83
+ }
84
+ const records = parseWorktreePorcelain(result.stdout);
85
+ const worktrees = [rootDescriptor];
86
+ const seen = new Set(["root"]);
87
+ const normalizeSlug = (record) => {
88
+ const branch = (record.branch ?? "").trim();
89
+ if (branch) {
90
+ return branch;
91
+ }
92
+ const head = (record.head ?? "").trim();
93
+ if (head && /^[0-9a-f]{7,40}$/i.test(head)) {
94
+ return `detached-${head.slice(0, 7)}`;
95
+ }
96
+ // Fallback: stable-ish identifier derived from directory basename.
97
+ const base = path.basename(record.worktree || "");
98
+ return base ? `worktree-${base}` : "worktree";
99
+ };
100
+ for (const record of records) {
101
+ const abs = record.worktree;
102
+ if (!abs || typeof abs !== "string")
103
+ continue;
104
+ // Skip the root record (we always expose it as slug="root").
105
+ if (path.resolve(abs) === path.resolve(repoRoot)) {
106
+ continue;
107
+ }
108
+ const slug = normalizeSlug(record);
109
+ if (!slug || slug === "root") {
110
+ continue;
111
+ }
112
+ if (seen.has(slug)) {
113
+ continue;
114
+ }
115
+ seen.add(slug);
116
+ worktrees.push({ slug, directory: abs, kind: "worktree", branch: record.branch });
117
+ }
118
+ return worktrees;
119
+ }
120
+ export function isValidWorktreeSlug(slug) {
121
+ if (!slug)
122
+ return false;
123
+ const trimmed = slug.trim();
124
+ if (!trimmed)
125
+ return false;
126
+ if (trimmed.length > 200)
127
+ return false;
128
+ // Disallow control characters; allow branch-like slugs including '/'.
129
+ if (/[\x00-\x1F\x7F]/.test(trimmed))
130
+ return false;
131
+ return true;
132
+ }
133
+ export async function createManagedWorktree(params) {
134
+ const { repoRoot, workspaceFolder, logger } = params;
135
+ const branch = params.slug.trim();
136
+ if (!branch || branch === "root" || !isValidWorktreeSlug(branch)) {
137
+ throw new Error("Invalid worktree slug");
138
+ }
139
+ const sanitizeDirName = (input) => {
140
+ const normalized = input
141
+ .trim()
142
+ .replace(/[\\/]+/g, "-")
143
+ .replace(/\s+/g, "-")
144
+ .replace(/[^a-zA-Z0-9_.-]+/g, "-")
145
+ .replace(/-{2,}/g, "-")
146
+ .replace(/^-+|-+$/g, "");
147
+ return normalized || "worktree";
148
+ };
149
+ const worktreesDir = path.join(repoRoot, ".codenomad", "worktrees");
150
+ const targetDir = path.join(worktreesDir, sanitizeDirName(branch));
151
+ await fsp.mkdir(worktreesDir, { recursive: true });
152
+ try {
153
+ const stat = await fsp.stat(targetDir);
154
+ if (stat.isDirectory()) {
155
+ throw new Error("Worktree directory already exists");
156
+ }
157
+ }
158
+ catch (error) {
159
+ const code = error.code;
160
+ if (code !== "ENOENT") {
161
+ throw error;
162
+ }
163
+ }
164
+ logger?.debug?.({ slug: branch, branch, targetDir }, "Creating managed git worktree");
165
+ // Prefer creating a new branch from HEAD.
166
+ const first = await runGit(["worktree", "add", "-b", branch, targetDir, "HEAD"], workspaceFolder);
167
+ if (first.ok) {
168
+ return { slug: branch, directory: targetDir, branch };
169
+ }
170
+ const message = first.stderr?.toLowerCase() ?? first.error.message.toLowerCase();
171
+ if (message.includes("already exists")) {
172
+ // If the branch already exists, add worktree for that branch.
173
+ const second = await runGit(["worktree", "add", targetDir, branch], workspaceFolder);
174
+ if (second.ok) {
175
+ return { slug: branch, directory: targetDir, branch };
176
+ }
177
+ throw second.error;
178
+ }
179
+ throw first.error;
180
+ }
181
+ export async function removeWorktree(params) {
182
+ const { workspaceFolder, logger } = params;
183
+ const directory = (params.directory ?? "").trim();
184
+ if (!directory) {
185
+ throw new Error("Invalid worktree directory");
186
+ }
187
+ logger?.debug?.({ directory, force: Boolean(params.force) }, "Removing git worktree");
188
+ const args = ["worktree", "remove"];
189
+ if (params.force) {
190
+ args.push("--force");
191
+ }
192
+ args.push(directory);
193
+ const result = await runGit(args, workspaceFolder);
194
+ if (!result.ok) {
195
+ throw result.error;
196
+ }
197
+ // Best-effort cleanup of stale metadata.
198
+ await runGit(["worktree", "prune"], workspaceFolder).catch(() => undefined);
199
+ }
@@ -70,7 +70,7 @@ export class InstanceEventBridge {
70
70
  }
71
71
  }
72
72
  async consumeStream(workspaceId, port, signal) {
73
- const url = `http://${INSTANCE_HOST}:${port}/event`;
73
+ const url = `http://${INSTANCE_HOST}:${port}/global/event`;
74
74
  const headers = { Accept: "text/event-stream" };
75
75
  const authHeader = this.options.workspaceManager.getInstanceAuthorizationHeader(workspaceId);
76
76
  if (authHeader) {
@@ -126,7 +126,27 @@ export class InstanceEventBridge {
126
126
  return;
127
127
  }
128
128
  try {
129
- const event = JSON.parse(payload);
129
+ const parsed = JSON.parse(payload);
130
+ if (!parsed || typeof parsed !== "object") {
131
+ this.options.logger.warn({ workspaceId, chunk: payload }, "Dropped malformed instance event");
132
+ return;
133
+ }
134
+ // OpenCode SSE payload shapes vary across versions.
135
+ // Common variants:
136
+ // - { type, properties, ... }
137
+ // - { payload: { type, properties, ... }, directory: "/abs/path" }
138
+ // - { payload: { type, properties, ... } }
139
+ const base = parsed.payload && typeof parsed.payload === "object" ? parsed.payload : parsed;
140
+ const event = base && typeof base === "object" ? { ...base } : null;
141
+ // Attach directory when available (don't overwrite if already present).
142
+ if (event && !event.directory && typeof parsed.directory === "string") {
143
+ ;
144
+ event.directory = parsed.directory;
145
+ }
146
+ if (!event || typeof event.type !== "string") {
147
+ this.options.logger.warn({ workspaceId, chunk: payload }, "Dropped malformed instance event");
148
+ return;
149
+ }
130
150
  this.options.logger.debug({ workspaceId, eventType: event.type }, "Instance SSE event received");
131
151
  if (this.options.logger.isLevelEnabled("trace")) {
132
152
  this.options.logger.trace({ workspaceId, event }, "Instance SSE event payload");
@@ -54,7 +54,7 @@ export class WorkspaceManager {
54
54
  const workspacePath = path.isAbsolute(folder) ? folder : path.resolve(this.options.rootDir, folder);
55
55
  clearWorkspaceSearchCache(workspacePath);
56
56
  this.options.logger.info({ workspaceId: id, folder: workspacePath, binary: resolvedBinaryPath }, "Creating workspace");
57
- const proxyPath = `/workspaces/${id}/instance`;
57
+ const proxyPath = `/workspaces/${id}/worktrees/root/instance`;
58
58
  const descriptor = {
59
59
  id,
60
60
  path: workspacePath,
@@ -86,6 +86,7 @@ export class WorkspaceManager {
86
86
  OPENCODE_CONFIG_DIR: this.opencodeConfigDir,
87
87
  CODENOMAD_INSTANCE_ID: id,
88
88
  CODENOMAD_BASE_URL: this.options.getServerBaseUrl(),
89
+ ...(this.options.nodeExtraCaCertsPath ? { NODE_EXTRA_CA_CERTS: this.options.nodeExtraCaCertsPath } : {}),
89
90
  [OPENCODE_SERVER_USERNAME_ENV]: opencodeUsername,
90
91
  [OPENCODE_SERVER_PASSWORD_ENV]: opencodePassword,
91
92
  };