@neuralnomads/codenomad-dev 0.13.3-dev-20260413-1ce58b9d → 0.14.0-dev-20260417-9bf4d351

package/dist/index.js

@@ -24,6 +24,9 @@ import { resolveNetworkAddresses, resolveRemoteAddresses } from "./server/networ
 import { startDevReleaseMonitor } from "./releases/dev-release-monitor";
 import { SpeechService } from "./speech/service";
 import { SideCarManager } from "./sidecars/manager";
+import { ClientConnectionManager } from "./clients/connection-manager";
+import { PluginChannelManager } from "./plugins/channel";
+import { VoiceModeManager } from "./plugins/voice-mode";
 const require = createRequire(import.meta.url);
 const packageJson = require("../package.json");
 const __filename = fileURLToPath(import.meta.url);
@@ -263,6 +266,13 @@ async function main() {
         throw new InvalidArgumentError("UI dev proxy is only supported with --https=false --http=true");
     }
     const remoteAccessEnabled = options.host === "0.0.0.0" || !isLoopbackHost(options.host);
+    const clientConnectionManager = new ClientConnectionManager(logger.child({ component: "client-connections" }));
+    const pluginChannel = new PluginChannelManager(logger.child({ component: "plugin-channel" }));
+    const voiceModeManager = new VoiceModeManager({
+        connections: clientConnectionManager,
+        channel: pluginChannel,
+        logger: logger.child({ component: "voice-mode" }),
+    });
     const httpsPortExplicit = programHasArg(process.argv.slice(2), "--https-port") || Boolean(process.env.CLI_HTTPS_PORT);
     const httpPortExplicit = programHasArg(process.argv.slice(2), "--http-port") || Boolean(process.env.CLI_HTTP_PORT);
     const httpsBindPort = httpsPortExplicit ? options.httpsPort : 0;
@@ -289,6 +299,9 @@ async function main() {
             speechService,
             sidecarManager,
             authManager,
+            clientConnectionManager,
+            pluginChannel,
+            voiceModeManager,
             uiStaticDir: uiResolution.uiStaticDir ?? DEFAULT_UI_STATIC_DIR,
             uiDevServerUrl: uiResolution.uiDevServerUrl,
             logger,
@@ -310,6 +323,9 @@ async function main() {
             speechService,
             sidecarManager,
             authManager,
+            clientConnectionManager,
+            pluginChannel,
+            voiceModeManager,
             uiStaticDir: uiResolution.uiStaticDir ?? DEFAULT_UI_STATIC_DIR,
             uiDevServerUrl: undefined,
             logger,
@@ -405,6 +421,12 @@ async function main() {
             catch (error) {
                 logger.error({ err: error }, "SideCar manager shutdown failed");
             }
+            try {
+                clientConnectionManager.shutdown();
+            }
+            catch (error) {
+                logger.warn({ err: error }, "Client connection manager shutdown failed");
+            }
             try {
                 await workspaceManager.shutdown();
                 logger.info("Workspace manager shutdown complete");

package/dist/plugins/voice-mode.js

@@ -12,7 +12,7 @@ export class VoiceModeManager {
     setEnabled(instanceId, connection, enabled) {
         if (enabled && !this.options.connections.isConnected(connection)) {
             this.options.logger.debug({ instanceId, clientId: connection.clientId, connectionId: connection.connectionId }, "Ignoring voice mode enable for disconnected client connection");
-            return;
+            return false;
         }
         const key = getConnectionKey(connection);
         const current = this.enabledConnectionsByInstance.get(instanceId) ?? new Set();
@@ -30,6 +30,7 @@ export class VoiceModeManager {
         }
         this.options.logger.debug({ instanceId, clientId: connection.clientId, connectionId: connection.connectionId, enabled }, "Voice mode updated for client connection");
         this.publishIfChanged(instanceId);
+        return true;
     }
     syncInstance(instanceId) {
         this.options.channel.send(instanceId, buildVoiceModeEvent(this.isEnabled(instanceId)));

package/dist/server/http-server.js

@@ -7,7 +7,8 @@ import { connect as connectTcp } from "net";
 import path from "path";
 import { connect as connectTls } from "tls";
 import { fetch } from "undici";
-import { isValidWorktreeSlug, listWorktrees, resolveRepoRoot } from "../workspaces/git-worktrees";
+import { isValidWorktreeSlug } from "../workspaces/git-worktrees";
+import { resolveWorktreeDirectory } from "../workspaces/worktree-directory";
 import { registerWorkspaceRoutes } from "./routes/workspaces";
 import { registerSettingsRoutes } from "./routes/settings";
 import { registerFilesystemRoutes } from "./routes/filesystem";
@@ -23,9 +24,6 @@ import { registerSideCarRoutes } from "./routes/sidecars";
 import { BackgroundProcessManager } from "../background-processes/manager";
 import { registerAuthRoutes } from "./routes/auth";
 import { sendUnauthorized, wantsHtml } from "../auth/http-auth";
-import { ClientConnectionManager } from "../clients/connection-manager";
-import { PluginChannelManager } from "../plugins/channel";
-import { VoiceModeManager } from "../plugins/voice-mode";
 export function createHttpServer(deps) {
     // Fastify's type-level RawServer inference gets noisy when toggling HTTP vs HTTPS.
     // We keep the runtime behavior correct and cast the instance to a generic FastifyInstance.
@@ -132,13 +130,6 @@ export function createHttpServer(deps) {
         eventBus: deps.eventBus,
         logger: deps.logger.child({ component: "background-processes" }),
     });
-    const clientConnectionManager = new ClientConnectionManager(deps.logger.child({ component: "client-connections" }));
-    const pluginChannel = new PluginChannelManager(deps.logger.child({ component: "plugin-channel" }));
-    const voiceModeManager = new VoiceModeManager({
-        connections: clientConnectionManager,
-        channel: pluginChannel,
-        logger: deps.logger.child({ component: "voice-mode" }),
-    });
     registerAuthRoutes(app, { authManager: deps.authManager });
     app.addHook("preHandler", (request, reply, done) => {
         const rawUrl = request.raw.url ?? request.url;
@@ -203,7 +194,7 @@ export function createHttpServer(deps) {
         eventBus: deps.eventBus,
         registerClient: registerSseClient,
         logger: sseLogger,
-        connectionManager: clientConnectionManager,
+        connectionManager: deps.clientConnectionManager,
     });
     registerWorktreeRoutes(app, { workspaceManager: deps.workspaceManager });
     registerStorageRoutes(app, {
@@ -224,8 +215,8 @@ export function createHttpServer(deps) {
         workspaceManager: deps.workspaceManager,
         eventBus: deps.eventBus,
         logger: proxyLogger,
-        channel: pluginChannel,
-        voiceModeManager,
+        channel: deps.pluginChannel,
+        voiceModeManager: deps.voiceModeManager,
     });
     registerBackgroundProcessRoutes(app, { backgroundProcessManager });
     registerInstanceProxyRoutes(app, { workspaceManager: deps.workspaceManager, logger: proxyLogger });
@@ -284,7 +275,6 @@ export function createHttpServer(deps) {
         },
         stop: () => {
             closeSseClients();
-            clientConnectionManager.shutdown();
             return app.close();
         },
     };
@@ -613,36 +603,6 @@ function normalizeInstanceSuffix(pathSuffix) {
     const trimmed = pathSuffix.replace(/^\/+/, "");
     return trimmed.length === 0 ? "/" : `/${trimmed}`;
 }
-const WORKTREE_CACHE_TTL_MS = 2000;
-const worktreeCache = new Map();
-async function getCachedWorktrees(params) {
-    const cached = worktreeCache.get(params.workspaceId);
-    const now = Date.now();
-    if (cached && cached.expiresAt > now) {
-        return cached;
-    }
-    const { repoRoot } = await resolveRepoRoot(params.workspacePath, params.logger);
-    const worktrees = await listWorktrees({ repoRoot, workspaceFolder: params.workspacePath, logger: params.logger });
-    const entry = {
-        expiresAt: now + WORKTREE_CACHE_TTL_MS,
-        repoRoot,
-        worktrees: worktrees.map((wt) => ({ slug: wt.slug, directory: wt.directory })),
-    };
-    worktreeCache.set(params.workspaceId, entry);
-    return entry;
-}
-async function resolveWorktreeDirectory(params) {
-    const { worktreeSlug } = params;
-    const cached = await getCachedWorktrees({ workspaceId: params.workspaceId, workspacePath: params.workspacePath, logger: params.logger });
-    const match = cached.worktrees.find((wt) => wt.slug === worktreeSlug);
-    if (match) {
-        return match.directory;
-    }
-    // If the slug is new (e.g., created moments ago), refresh once.
-    worktreeCache.delete(params.workspaceId);
-    const refreshed = await getCachedWorktrees({ workspaceId: params.workspaceId, workspacePath: params.workspacePath, logger: params.logger });
-    return refreshed.worktrees.find((wt) => wt.slug === worktreeSlug)?.directory ?? null;
-}
 function setupStaticUi(app, uiDir, authManager) {
     if (!uiDir) {
         app.log.warn("UI static directory not provided; API endpoints only");

package/dist/server/routes/plugin.js

@@ -41,7 +41,11 @@ export function registerPluginRoutes(app, deps) {
             return;
         }
         const payload = VoiceModeStateSchema.parse(request.body ?? {});
-        deps.voiceModeManager.setEnabled(request.params.id, { clientId: payload.clientId, connectionId: payload.connectionId }, payload.enabled);
+        const applied = deps.voiceModeManager.setEnabled(request.params.id, { clientId: payload.clientId, connectionId: payload.connectionId }, payload.enabled);
+        if (payload.enabled && !applied) {
+            reply.code(409).send({ error: "Client connection not active for voice mode enable" });
+            return;
+        }
         return { enabled: payload.enabled };
     });
     const handleWildcard = async (request, reply) => {

package/dist/server/routes/workspaces.js

@@ -1,4 +1,8 @@
 import { z } from "zod";
+import { getWorktreeGitDiff, getWorktreeGitStatus } from "../../workspaces/git-status";
+import { commitWorktreeChanges, isGitMutationError, stageWorktreePaths, unstageWorktreePaths } from "../../workspaces/git-mutations";
+import { isGitAvailable, resolveRepoRoot } from "../../workspaces/git-worktrees";
+import { resolveWorktreeDirectory } from "../../workspaces/worktree-directory";
 const WorkspaceCreateSchema = z.object({
     path: z.string(),
     name: z.string().optional(),
@@ -12,6 +16,17 @@ const WorkspaceFileContentQuerySchema = z.object({
 const WorkspaceFileContentBodySchema = z.object({
     contents: z.string(),
 });
+const WorktreeGitDiffQuerySchema = z.object({
+    path: z.string().trim().min(1, "Path is required"),
+    originalPath: z.string().trim().optional(),
+    scope: z.enum(["staged", "unstaged"]),
+});
+const WorktreeGitPathsBodySchema = z.object({
+    paths: z.array(z.string().trim().min(1, "Path is required")).min(1, "At least one path is required"),
+});
+const WorktreeGitCommitBodySchema = z.object({
+    message: z.string().trim().min(1, "Commit message is required"),
+});
 const WorkspaceFileSearchQuerySchema = z.object({
     q: z.string().trim().min(1, "Query is required"),
     limit: z.coerce.number().int().positive().max(200).optional(),
@@ -92,8 +107,111 @@ export function registerWorkspaceRoutes(app, deps) {
             return handleWorkspaceError(error, reply);
         }
     });
+    app.get("/api/workspaces/:id/worktrees/:slug/git-status", async (request, reply) => {
+        try {
+            const directory = await resolveGitWorktreeDirectory(deps.workspaceManager, request.params.id, request.params.slug, request.log, reply);
+            if (!directory)
+                return;
+            return await getWorktreeGitStatus({ workspaceFolder: directory, logger: request.log });
+        }
+        catch (error) {
+            return handleWorkspaceError(error, reply);
+        }
+    });
+    app.get("/api/workspaces/:id/worktrees/:slug/git-diff", async (request, reply) => {
+        try {
+            const query = WorktreeGitDiffQuerySchema.parse(request.query ?? {});
+            const directory = await resolveGitWorktreeDirectory(deps.workspaceManager, request.params.id, request.params.slug, request.log, reply);
+            if (!directory)
+                return;
+            return await getWorktreeGitDiff({
+                workspaceFolder: directory,
+                path: query.path,
+                originalPath: query.originalPath,
+                scope: query.scope,
+            });
+        }
+        catch (error) {
+            return handleWorkspaceError(error, reply);
+        }
+    });
+    app.post("/api/workspaces/:id/worktrees/:slug/git-stage", async (request, reply) => {
+        try {
+            const body = WorktreeGitPathsBodySchema.parse(request.body ?? {});
+            const directory = await resolveGitWorktreeDirectory(deps.workspaceManager, request.params.id, request.params.slug, request.log, reply);
+            if (!directory)
+                return;
+            await stageWorktreePaths({ workspaceFolder: directory, paths: body.paths });
+            return { ok: true };
+        }
+        catch (error) {
+            return handleWorkspaceError(error, reply);
+        }
+    });
+    app.post("/api/workspaces/:id/worktrees/:slug/git-unstage", async (request, reply) => {
+        try {
+            const body = WorktreeGitPathsBodySchema.parse(request.body ?? {});
+            const directory = await resolveGitWorktreeDirectory(deps.workspaceManager, request.params.id, request.params.slug, request.log, reply);
+            if (!directory)
+                return;
+            await unstageWorktreePaths({ workspaceFolder: directory, paths: body.paths });
+            return { ok: true };
+        }
+        catch (error) {
+            return handleWorkspaceError(error, reply);
+        }
+    });
+    app.post("/api/workspaces/:id/worktrees/:slug/git-commit", async (request, reply) => {
+        try {
+            const body = WorktreeGitCommitBodySchema.parse(request.body ?? {});
+            const directory = await resolveGitWorktreeDirectory(deps.workspaceManager, request.params.id, request.params.slug, request.log, reply);
+            if (!directory)
+                return;
+            const result = await commitWorktreeChanges({ workspaceFolder: directory, message: body.message });
+            return { ok: true, ...result };
+        }
+        catch (error) {
+            return handleWorkspaceError(error, reply);
+        }
+    });
+}
+async function resolveGitWorktreeDirectory(workspaceManager, workspaceId, worktreeSlug, logger, reply) {
+    const workspace = workspaceManager.get(workspaceId);
+    if (!workspace) {
+        reply.code(404);
+        reply.send({ error: "Workspace not found" });
+        return null;
+    }
+    const gitAvailable = await isGitAvailable(workspace.path);
+    if (!gitAvailable) {
+        reply.code(503);
+        reply.send({ error: "Git is not installed or not available in PATH" });
+        return null;
+    }
+    const { isGitRepo } = await resolveRepoRoot(workspace.path, logger);
+    if (!isGitRepo) {
+        reply.code(400);
+        reply.send({ error: "Workspace is not a Git repository" });
+        return null;
+    }
+    const directory = await resolveWorktreeDirectory({
+        workspaceId: workspace.id,
+        workspacePath: workspace.path,
+        worktreeSlug,
+        logger,
+    });
+    if (!directory) {
+        reply.code(404);
+        reply.send({ error: "Worktree not found" });
+        return null;
+    }
+    return directory;
 }
 function handleWorkspaceError(error, reply) {
+    if (isGitMutationError(error)) {
+        reply.code(error.statusCode);
+        return { error: error.message };
+    }
     if (error instanceof Error && error.message === "Workspace not found") {
         reply.code(404);
         return { error: "Workspace not found" };

package/dist/workspaces/git-mutations.js

@@ -0,0 +1,98 @@
+import { spawn } from "child_process";
+import path from "path";
+class GitMutationError extends Error {
+    constructor(message, statusCode = 400) {
+        super(message);
+        this.name = "GitMutationError";
+        this.statusCode = statusCode;
+    }
+}
+function runGit(args, cwd) {
+    return new Promise((resolve) => {
+        const child = spawn("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+        let stdout = "";
+        let stderr = "";
+        child.stdout?.on("data", (chunk) => {
+            stdout += chunk.toString();
+        });
+        child.stderr?.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.once("error", (error) => {
+            resolve({ ok: false, error, stdout, stderr });
+        });
+        child.once("close", (code) => {
+            if (code === 0) {
+                resolve({ ok: true, stdout });
+            }
+            else {
+                const error = new Error(stderr.trim() || `git ${args.join(" ")} failed with code ${code}`);
+                resolve({ ok: false, error, stdout, stderr });
+            }
+        });
+    });
+}
+export function normalizeGitWorktreeRelativePath(input) {
+    const normalized = input.trim().replace(/\\+/g, "/").replace(/^\.\//, "");
+    if (!normalized) {
+        throw new GitMutationError("Path is required", 400);
+    }
+    if (path.posix.isAbsolute(normalized) || path.win32.isAbsolute(normalized)) {
+        throw new GitMutationError(`Absolute paths are not allowed: ${input}`, 400);
+    }
+    if (normalized === "." || normalized === "..") {
+        throw new GitMutationError(`Invalid path: ${input}`, 400);
+    }
+    if (normalized.startsWith("../") || normalized.includes("/../") || normalized.endsWith("/..")) {
+        throw new GitMutationError(`Path traversal is not allowed: ${input}`, 400);
+    }
+    return normalized;
+}
+function normalizeGitMutationPaths(paths) {
+    const deduped = new Set();
+    for (const rawPath of paths) {
+        deduped.add(normalizeGitWorktreeRelativePath(rawPath));
+    }
+    const normalized = Array.from(deduped);
+    if (normalized.length === 0) {
+        throw new GitMutationError("At least one path is required", 400);
+    }
+    return normalized;
+}
+async function ensureGitCommandSucceeded(resultPromise, fallbackMessage) {
+    const result = await resultPromise;
+    if (!result.ok) {
+        const message = result.stderr?.trim() || result.error.message || fallbackMessage;
+        throw new GitMutationError(message, 409);
+    }
+    return result.stdout;
+}
+export function isGitMutationError(error) {
+    return error instanceof GitMutationError;
+}
+export async function stageWorktreePaths(params) {
+    const paths = normalizeGitMutationPaths(params.paths);
+    await ensureGitCommandSucceeded(runGit(["add", "--", ...paths], params.workspaceFolder), "Failed to stage files");
+}
+export async function unstageWorktreePaths(params) {
+    const paths = normalizeGitMutationPaths(params.paths);
+    const headResult = await runGit(["rev-parse", "--verify", "HEAD"], params.workspaceFolder);
+    if (headResult.ok) {
+        await ensureGitCommandSucceeded(runGit(["restore", "--staged", "--", ...paths], params.workspaceFolder), "Failed to unstage files");
+        return;
+    }
+    await ensureGitCommandSucceeded(runGit(["rm", "--cached", "--quiet", "--", ...paths], params.workspaceFolder), "Failed to unstage files");
+}
+export async function commitWorktreeChanges(params) {
+    const message = params.message.trim();
+    if (!message) {
+        throw new GitMutationError("Commit message is required", 400);
+    }
+    await ensureGitCommandSucceeded(runGit(["commit", "-m", message], params.workspaceFolder), "Failed to create commit");
+    const shaResult = await runGit(["rev-parse", "HEAD"], params.workspaceFolder);
+    if (!shaResult.ok) {
+        return {};
+    }
+    const commitSha = shaResult.stdout.trim();
+    return commitSha ? { commitSha } : {};
+}