@gokulvenkatareddy/cortex 0.1.7

package/apps/octogent/apps/api/src/createApiServer/gitParsers.ts

@@ -0,0 +1,140 @@
+export const parseTentacleCommitMessage = (
+  payload: unknown,
+): { message: string | null; error: string | null } => {
+  if (payload === null || payload === undefined || typeof payload !== "object") {
+    return {
+      message: null,
+      error: "Expected a JSON object body.",
+    };
+  }
+
+  const rawMessage = (payload as Record<string, unknown>).message;
+  if (typeof rawMessage !== "string") {
+    return {
+      message: null,
+      error: "Commit message must be a string.",
+    };
+  }
+
+  const trimmed = rawMessage.trim();
+  if (trimmed.length === 0) {
+    return {
+      message: null,
+      error: "Commit message cannot be empty.",
+    };
+  }
+
+  return {
+    message: trimmed,
+    error: null,
+  };
+};
+
+export const parseTentacleSyncBaseRef = (
+  payload: unknown,
+): { baseRef: string | null; error: string | null } => {
+  if (payload === null || payload === undefined) {
+    return {
+      baseRef: null,
+      error: null,
+    };
+  }
+
+  if (typeof payload !== "object") {
+    return {
+      baseRef: null,
+      error: "Expected a JSON object body.",
+    };
+  }
+
+  const rawBaseRef = (payload as Record<string, unknown>).baseRef;
+  if (rawBaseRef === undefined) {
+    return {
+      baseRef: null,
+      error: null,
+    };
+  }
+
+  if (typeof rawBaseRef !== "string") {
+    return {
+      baseRef: null,
+      error: "baseRef must be a string.",
+    };
+  }
+
+  const trimmed = rawBaseRef.trim();
+  if (trimmed.length === 0) {
+    return {
+      baseRef: null,
+      error: "baseRef cannot be empty.",
+    };
+  }
+
+  return {
+    baseRef: trimmed,
+    error: null,
+  };
+};
+
+export const parseTentaclePullRequestCreateInput = (
+  payload: unknown,
+): {
+  title: string | null;
+  body: string;
+  baseRef: string | null;
+  error: string | null;
+} => {
+  if (payload === null || payload === undefined || typeof payload !== "object") {
+    return {
+      title: null,
+      body: "",
+      baseRef: null,
+      error: "Expected a JSON object body.",
+    };
+  }
+
+  const record = payload as Record<string, unknown>;
+  if (typeof record.title !== "string" || record.title.trim().length === 0) {
+    return {
+      title: null,
+      body: "",
+      baseRef: null,
+      error: "Pull request title cannot be empty.",
+    };
+  }
+
+  if (record.body !== undefined && typeof record.body !== "string") {
+    return {
+      title: null,
+      body: "",
+      baseRef: null,
+      error: "Pull request body must be a string.",
+    };
+  }
+
+  if (record.baseRef !== undefined && typeof record.baseRef !== "string") {
+    return {
+      title: null,
+      body: "",
+      baseRef: null,
+      error: "Pull request baseRef must be a string.",
+    };
+  }
+
+  const normalizedBaseRef = typeof record.baseRef === "string" ? record.baseRef.trim() : "";
+  if (record.baseRef !== undefined && normalizedBaseRef.length === 0) {
+    return {
+      title: null,
+      body: "",
+      baseRef: null,
+      error: "Pull request baseRef cannot be empty.",
+    };
+  }
+
+  return {
+    title: record.title.trim(),
+    body: typeof record.body === "string" ? record.body : "",
+    baseRef: normalizedBaseRef.length > 0 ? normalizedBaseRef : null,
+    error: null,
+  };
+};

package/apps/octogent/apps/api/src/createApiServer/gitRoutes.ts

@@ -0,0 +1,214 @@
+import { RuntimeInputError } from "../terminalRuntime";
+import {
+  parseTentacleCommitMessage,
+  parseTentaclePullRequestCreateInput,
+  parseTentacleSyncBaseRef,
+} from "./gitParsers";
+import type { ApiRouteHandler } from "./routeHelpers";
+import { readJsonBodyOrWriteError, writeJson, writeMethodNotAllowed } from "./routeHelpers";
+
+const TENTACLE_GIT_ACTION_PATH_PATTERN =
+  /^\/api\/tentacles\/([^/]+)\/git\/(status|commit|push|sync)$/;
+const TENTACLE_GIT_PULL_REQUEST_PATH_PATTERN = /^\/api\/tentacles\/([^/]+)\/git\/pr$/;
+const TENTACLE_GIT_PULL_REQUEST_MERGE_PATH_PATTERN = /^\/api\/tentacles\/([^/]+)\/git\/pr\/merge$/;
+
+export const handleTentacleGitRoute: ApiRouteHandler = async (
+  { request, response, requestUrl, corsOrigin },
+  { runtime },
+) => {
+  const gitMatch = requestUrl.pathname.match(TENTACLE_GIT_ACTION_PATH_PATTERN);
+  if (!gitMatch) {
+    return false;
+  }
+
+  const tentacleId = decodeURIComponent(gitMatch[1] ?? "");
+  const action = gitMatch[2];
+
+  try {
+    if (action === "status") {
+      if (request.method !== "GET") {
+        writeMethodNotAllowed(response, corsOrigin);
+        return true;
+      }
+
+      const payload = runtime.readTentacleGitStatus(tentacleId);
+      if (!payload) {
+        writeJson(response, 404, { error: "Tentacle not found." }, corsOrigin);
+        return true;
+      }
+
+      writeJson(response, 200, payload, corsOrigin);
+      return true;
+    }
+
+    if (action === "commit") {
+      if (request.method !== "POST") {
+        writeMethodNotAllowed(response, corsOrigin);
+        return true;
+      }
+
+      const bodyReadResult = await readJsonBodyOrWriteError(request, response, corsOrigin);
+      if (!bodyReadResult.ok) {
+        return true;
+      }
+
+      const commitMessageResult = parseTentacleCommitMessage(bodyReadResult.payload);
+      if (commitMessageResult.error || !commitMessageResult.message) {
+        writeJson(
+          response,
+          400,
+          { error: commitMessageResult.error ?? "Commit message cannot be empty." },
+          corsOrigin,
+        );
+        return true;
+      }
+
+      const payload = runtime.commitTentacleWorktree(tentacleId, commitMessageResult.message);
+      if (!payload) {
+        writeJson(response, 404, { error: "Tentacle not found." }, corsOrigin);
+        return true;
+      }
+
+      writeJson(response, 200, payload, corsOrigin);
+      return true;
+    }
+
+    if (action === "push") {
+      if (request.method !== "POST") {
+        writeMethodNotAllowed(response, corsOrigin);
+        return true;
+      }
+
+      const payload = runtime.pushTentacleWorktree(tentacleId);
+      if (!payload) {
+        writeJson(response, 404, { error: "Tentacle not found." }, corsOrigin);
+        return true;
+      }
+
+      writeJson(response, 200, payload, corsOrigin);
+      return true;
+    }
+
+    if (request.method !== "POST") {
+      writeMethodNotAllowed(response, corsOrigin);
+      return true;
+    }
+
+    const bodyReadResult = await readJsonBodyOrWriteError(request, response, corsOrigin);
+    if (!bodyReadResult.ok) {
+      return true;
+    }
+
+    const baseRefResult = parseTentacleSyncBaseRef(bodyReadResult.payload);
+    if (baseRefResult.error) {
+      writeJson(response, 400, { error: baseRefResult.error }, corsOrigin);
+      return true;
+    }
+
+    const payload = runtime.syncTentacleWorktree(tentacleId, baseRefResult.baseRef ?? undefined);
+    if (!payload) {
+      writeJson(response, 404, { error: "Tentacle not found." }, corsOrigin);
+      return true;
+    }
+
+    writeJson(response, 200, payload, corsOrigin);
+    return true;
+  } catch (error) {
+    if (error instanceof RuntimeInputError) {
+      writeJson(response, 409, { error: error.message }, corsOrigin);
+      return true;
+    }
+    throw error;
+  }
+};
+
+export const handleTentacleGitPullRequestRoute: ApiRouteHandler = async (
+  { request, response, requestUrl, corsOrigin },
+  { runtime },
+) => {
+  const mergeMatch = requestUrl.pathname.match(TENTACLE_GIT_PULL_REQUEST_MERGE_PATH_PATTERN);
+  if (mergeMatch) {
+    if (request.method !== "POST") {
+      writeMethodNotAllowed(response, corsOrigin);
+      return true;
+    }
+
+    const tentacleId = decodeURIComponent(mergeMatch[1] ?? "");
+    try {
+      const payload = runtime.mergeTentaclePullRequest(tentacleId);
+      if (!payload) {
+        writeJson(response, 404, { error: "Tentacle not found." }, corsOrigin);
+        return true;
+      }
+
+      writeJson(response, 200, payload, corsOrigin);
+      return true;
+    } catch (error) {
+      if (error instanceof RuntimeInputError) {
+        writeJson(response, 409, { error: error.message }, corsOrigin);
+        return true;
+      }
+      throw error;
+    }
+  }
+
+  const prMatch = requestUrl.pathname.match(TENTACLE_GIT_PULL_REQUEST_PATH_PATTERN);
+  if (!prMatch) {
+    return false;
+  }
+
+  const tentacleId = decodeURIComponent(prMatch[1] ?? "");
+
+  try {
+    if (request.method === "GET") {
+      const payload = runtime.readTentaclePullRequest(tentacleId);
+      if (!payload) {
+        writeJson(response, 404, { error: "Tentacle not found." }, corsOrigin);
+        return true;
+      }
+
+      writeJson(response, 200, payload, corsOrigin);
+      return true;
+    }
+
+    if (request.method !== "POST") {
+      writeMethodNotAllowed(response, corsOrigin);
+      return true;
+    }
+
+    const bodyReadResult = await readJsonBodyOrWriteError(request, response, corsOrigin);
+    if (!bodyReadResult.ok) {
+      return true;
+    }
+
+    const pullRequestInput = parseTentaclePullRequestCreateInput(bodyReadResult.payload);
+    if (pullRequestInput.error || !pullRequestInput.title) {
+      writeJson(
+        response,
+        400,
+        { error: pullRequestInput.error ?? "Pull request title cannot be empty." },
+        corsOrigin,
+      );
+      return true;
+    }
+
+    const payload = runtime.createTentaclePullRequest(tentacleId, {
+      title: pullRequestInput.title,
+      ...(pullRequestInput.body.length > 0 ? { body: pullRequestInput.body } : {}),
+      ...(pullRequestInput.baseRef !== null ? { baseRef: pullRequestInput.baseRef } : {}),
+    });
+    if (!payload) {
+      writeJson(response, 404, { error: "Tentacle not found." }, corsOrigin);
+      return true;
+    }
+
+    writeJson(response, 200, payload, corsOrigin);
+    return true;
+  } catch (error) {
+    if (error instanceof RuntimeInputError) {
+      writeJson(response, 409, { error: error.message }, corsOrigin);
+      return true;
+    }
+    throw error;
+  }
+};

package/apps/octogent/apps/api/src/createApiServer/miscRoutes.ts

@@ -0,0 +1,316 @@
+import type { WorkspaceSetupStepId } from "@octogent/core";
+
+import {
+  deleteUserPrompt,
+  listAllPrompts,
+  readPromptFromDirs,
+  resolvePrompt,
+  writeUserPrompt,
+} from "../prompts";
+import { markSetupStepVerified } from "../setupState";
+import {
+  ensureWorkspaceGitignore,
+  initializeWorkspaceFiles,
+  readWorkspaceSetupSnapshot,
+} from "../setupStatus";
+import type { ApiRouteHandler } from "./routeHelpers";
+import {
+  readJsonBodyOrWriteError,
+  writeJson,
+  writeMethodNotAllowed,
+  writeNoContent,
+} from "./routeHelpers";
+import { parseUiStatePatch } from "./uiStateParsers";
+
+const WORKSPACE_SETUP_PATH = "/api/setup";
+const WORKSPACE_SETUP_STEP_PATH_PATTERN = /^\/api\/setup\/steps\/([^/]+)$/;
+
+const isWorkspaceSetupStepId = (value: string): value is WorkspaceSetupStepId =>
+  value === "initialize-workspace" ||
+  value === "ensure-gitignore" ||
+  value === "check-claude" ||
+  value === "check-git" ||
+  value === "check-curl" ||
+  value === "create-tentacles";
+
+export const handleWorkspaceSetupRoute: ApiRouteHandler = async (
+  { request, response, requestUrl, corsOrigin },
+  { workspaceCwd, projectStateDir },
+) => {
+  if (requestUrl.pathname === WORKSPACE_SETUP_PATH) {
+    if (request.method !== "GET") {
+      writeMethodNotAllowed(response, corsOrigin);
+      return true;
+    }
+
+    writeJson(response, 200, readWorkspaceSetupSnapshot(workspaceCwd, projectStateDir), corsOrigin);
+    return true;
+  }
+
+  const match = requestUrl.pathname.match(WORKSPACE_SETUP_STEP_PATH_PATTERN);
+  if (!match) {
+    return false;
+  }
+
+  const stepId = decodeURIComponent(match[1] ?? "");
+  if (!isWorkspaceSetupStepId(stepId)) {
+    writeJson(response, 404, { error: "Setup step not found." }, corsOrigin);
+    return true;
+  }
+
+  if (request.method !== "POST") {
+    writeMethodNotAllowed(response, corsOrigin);
+    return true;
+  }
+
+  if (stepId === "initialize-workspace") {
+    initializeWorkspaceFiles(workspaceCwd, projectStateDir);
+  } else if (stepId === "ensure-gitignore") {
+    ensureWorkspaceGitignore(workspaceCwd);
+  } else if (stepId === "check-claude" || stepId === "check-git" || stepId === "check-curl") {
+    markSetupStepVerified(projectStateDir, stepId);
+  }
+
+  writeJson(response, 200, readWorkspaceSetupSnapshot(workspaceCwd, projectStateDir), corsOrigin);
+  return true;
+};
+
+export const handleUiStateRoute: ApiRouteHandler = async (
+  { request, response, requestUrl, corsOrigin },
+  { runtime },
+) => {
+  if (requestUrl.pathname !== "/api/ui-state") {
+    return false;
+  }
+
+  if (request.method === "GET") {
+    const payload = runtime.readUiState();
+    writeJson(response, 200, payload, corsOrigin);
+    return true;
+  }
+
+  if (request.method !== "PATCH") {
+    writeMethodNotAllowed(response, corsOrigin);
+    return true;
+  }
+
+  const bodyReadResult = await readJsonBodyOrWriteError(request, response, corsOrigin);
+  if (!bodyReadResult.ok) {
+    return true;
+  }
+
+  const uiStatePatch = parseUiStatePatch(bodyReadResult.payload);
+  if (uiStatePatch.error || !uiStatePatch.patch) {
+    writeJson(
+      response,
+      400,
+      { error: uiStatePatch.error ?? "Invalid UI state patch." },
+      corsOrigin,
+    );
+    return true;
+  }
+
+  const payload = runtime.patchUiState(uiStatePatch.patch);
+  writeJson(response, 200, payload, corsOrigin);
+  return true;
+};
+
+const HOOK_PATH_PATTERN =
+  /^\/api\/hooks\/(session-start|user-prompt-submit|pre-tool-use|notification|stop)$/;
+
+export const handleHookRoute: ApiRouteHandler = async (
+  { request, response, requestUrl, corsOrigin },
+  { runtime, invalidateClaudeUsageCache, readClaudeUsageSnapshot },
+) => {
+  const match = requestUrl.pathname.match(HOOK_PATH_PATTERN);
+  if (!match) {
+    return false;
+  }
+
+  if (request.method !== "POST") {
+    writeMethodNotAllowed(response, corsOrigin);
+    return true;
+  }
+
+  const body = await readJsonBodyOrWriteError(request, response, corsOrigin);
+  if (!body.ok) {
+    return true;
+  }
+
+  const hookName = match[1] ?? "";
+  // HTTP hooks pass the session ID via header; command hooks via query param.
+  const octogentSessionId =
+    (typeof request.headers["x-octogent-session"] === "string"
+      ? request.headers["x-octogent-session"]
+      : undefined) ??
+    requestUrl.searchParams.get("octogent_session") ??
+    undefined;
+  const result = runtime.handleHook(hookName, body.payload, octogentSessionId);
+
+  if (hookName === "session-start" || hookName === "stop") {
+    invalidateClaudeUsageCache();
+    void readClaudeUsageSnapshot();
+  }
+
+  writeJson(response, 200, result, corsOrigin);
+  return true;
+};
+
+const PROMPT_ITEM_PATH_PATTERN = /^\/api\/prompts\/([^/]+)$/;
+
+export const handlePromptsCollectionRoute: ApiRouteHandler = async (
+  { request, response, requestUrl, corsOrigin },
+  { promptsDir, userPromptsDir },
+) => {
+  if (requestUrl.pathname !== "/api/prompts") {
+    return false;
+  }
+
+  if (request.method === "GET") {
+    const prompts = await listAllPrompts(promptsDir, userPromptsDir);
+    writeJson(response, 200, { prompts }, corsOrigin);
+    return true;
+  }
+
+  if (request.method === "POST") {
+    const bodyResult = await readJsonBodyOrWriteError(request, response, corsOrigin);
+    if (!bodyResult.ok) return true;
+
+    const body = bodyResult.payload as Record<string, unknown> | null;
+    const name = body && typeof body.name === "string" ? body.name.trim() : "";
+    const content = body && typeof body.content === "string" ? body.content : "";
+
+    if (name.length === 0) {
+      writeJson(response, 400, { error: "Prompt name is required." }, corsOrigin);
+      return true;
+    }
+
+    const ok = await writeUserPrompt(userPromptsDir, name, content);
+    if (!ok) {
+      writeJson(response, 400, { error: "Invalid prompt name." }, corsOrigin);
+      return true;
+    }
+
+    writeJson(response, 201, { name, source: "user" }, corsOrigin);
+    return true;
+  }
+
+  writeMethodNotAllowed(response, corsOrigin);
+  return true;
+};
+
+export const handlePromptItemRoute: ApiRouteHandler = async (
+  { request, response, requestUrl, corsOrigin },
+  { promptsDir, userPromptsDir },
+) => {
+  const match = requestUrl.pathname.match(PROMPT_ITEM_PATH_PATTERN);
+  if (!match) return false;
+
+  const name = decodeURIComponent(match[1] as string);
+
+  if (request.method === "GET") {
+    // Resolve variables from query params (e.g. ?tentacleId=sandbox).
+    const variables: Record<string, string> = {};
+    for (const [key, value] of requestUrl.searchParams.entries()) {
+      variables[key] = value;
+    }
+
+    const hasVariables = Object.keys(variables).length > 0;
+    if (hasVariables) {
+      const resolved = await resolvePrompt(promptsDir, name, variables);
+      if (resolved === undefined) {
+        writeJson(response, 404, { error: "Prompt template not found" }, corsOrigin);
+        return true;
+      }
+      writeJson(response, 200, { name, prompt: resolved }, corsOrigin);
+    } else {
+      const result = await readPromptFromDirs(promptsDir, userPromptsDir, name);
+      if (result === undefined) {
+        writeJson(response, 404, { error: "Prompt template not found" }, corsOrigin);
+        return true;
+      }
+      writeJson(response, 200, result, corsOrigin);
+    }
+    return true;
+  }
+
+  if (request.method === "PUT") {
+    const bodyResult = await readJsonBodyOrWriteError(request, response, corsOrigin);
+    if (!bodyResult.ok) return true;
+
+    const body = bodyResult.payload as Record<string, unknown> | null;
+    const content = body && typeof body.content === "string" ? body.content : "";
+
+    const ok = await writeUserPrompt(userPromptsDir, name, content);
+    if (!ok) {
+      writeJson(response, 400, { error: "Invalid prompt name." }, corsOrigin);
+      return true;
+    }
+    writeJson(response, 200, { name, source: "user", content }, corsOrigin);
+    return true;
+  }
+
+  if (request.method === "DELETE") {
+    const ok = await deleteUserPrompt(userPromptsDir, name);
+    if (!ok) {
+      writeJson(response, 404, { error: "Prompt not found or cannot be deleted." }, corsOrigin);
+      return true;
+    }
+    writeNoContent(response, 204, corsOrigin);
+    return true;
+  }
+
+  writeMethodNotAllowed(response, corsOrigin);
+  return true;
+};
+
+// ─── Channel routes ───────────────────────────────────────────────────────
+
+const CHANNEL_MESSAGES_PATH_PATTERN = /^\/api\/channels\/([^/]+)\/messages$/;
+
+export const handleChannelMessagesRoute: ApiRouteHandler = async (
+  { request, response, requestUrl, corsOrigin },
+  { runtime },
+) => {
+  const match = requestUrl.pathname.match(CHANNEL_MESSAGES_PATH_PATTERN);
+  if (!match) {
+    return false;
+  }
+
+  const terminalId = decodeURIComponent(match[1] ?? "");
+
+  if (request.method === "GET") {
+    const messages = runtime.listChannelMessages(terminalId);
+    writeJson(response, 200, { terminalId, messages }, corsOrigin);
+    return true;
+  }
+
+  if (request.method !== "POST") {
+    writeMethodNotAllowed(response, corsOrigin);
+    return true;
+  }
+
+  const bodyReadResult = await readJsonBodyOrWriteError(request, response, corsOrigin);
+  if (!bodyReadResult.ok) {
+    return true;
+  }
+
+  const body = bodyReadResult.payload as Record<string, unknown> | null;
+  const fromTerminalId =
+    body && typeof body.fromTerminalId === "string" ? body.fromTerminalId.trim() : "";
+  const content = body && typeof body.content === "string" ? body.content.trim() : "";
+
+  if (content.length === 0) {
+    writeJson(response, 400, { error: "Message content cannot be empty." }, corsOrigin);
+    return true;
+  }
+
+  const message = runtime.sendChannelMessage(terminalId, fromTerminalId, content);
+  if (!message) {
+    writeJson(response, 404, { error: "Target terminal not found." }, corsOrigin);
+    return true;
+  }
+
+  writeJson(response, 201, message, corsOrigin);
+  return true;
+};