@suchitraswain/nightcode-cli 1.0.0

package/src/lib/local-tools.ts

@@ -0,0 +1,170 @@
+import { mkdir, readFile, readdir, stat, writeFile } from "fs/promises";
+import { dirname, isAbsolute, join, relative, resolve } from "path";
+import { toolInputSchemas, Mode, type ModeType } from "@nightcode/shared";
+
+const MAX_FILE_SIZE = 10_000;
+const MAX_RESULTS = 200;
+const MAX_MATCHES = 50;
+const MAX_OUTPUT = 20_000;
+const DEFAULT_TIMEOUT = 30_000;
+
+function resolveInsideCwd(path: string) {
+  const cwd = process.cwd();
+  const resolved = resolve(cwd, path);
+  const rel = relative(cwd, resolved);
+
+  if (rel.startsWith("..") || isAbsolute(rel)) {
+    throw new Error("Path is outside the project directory");
+  }
+
+  return { cwd, resolved };
+}
+
+function truncate(value: string, limit: number) {
+  return value.length > limit
+    ? `${value.slice(0, limit)}\n... (truncated, ${value.length} total chars)`
+    : value;
+}
+
+export async function executeLocalTool(toolName: string, input: unknown, mode: ModeType) {
+  if (mode === Mode.PLAN && !["readFile", "listDirectory", "glob", "grep"].includes(toolName)) {
+    throw new Error(`Tool ${toolName} is not available in PLAN mode`);
+  }
+
+  switch (toolName) {
+    case "readFile": {
+      const { path } = toolInputSchemas.readFile.parse(input);
+      const { resolved } = resolveInsideCwd(path);
+      const content = await readFile(resolved, "utf-8");
+      return content.length > MAX_FILE_SIZE
+        ? { content: content.slice(0, MAX_FILE_SIZE), truncated: true, totalLength: content.length }
+        : { content };
+    }
+    case "listDirectory": {
+      const { path } = toolInputSchemas.listDirectory.parse(input);
+      const { cwd, resolved } = resolveInsideCwd(path);
+      const entries = await readdir(resolved);
+      const results: { name: string; type: "file" | "directory" }[] = [];
+
+      for (const entry of entries) {
+        if (entry.startsWith(".") || entry === "node_modules") continue;
+        const info = await stat(join(resolved, entry));
+        results.push({ name: entry, type: info.isDirectory() ? "directory" : "file" });
+      }
+
+      results.sort((a, b) =>
+        a.type !== b.type ? (a.type === "directory" ? -1 : 1) : a.name.localeCompare(b.name),
+      );
+      return { path: relative(cwd, resolved) || ".", entries: results };
+    }
+    case "glob": {
+      const { pattern, path } = toolInputSchemas.glob.parse(input);
+      const { cwd, resolved } = resolveInsideCwd(path);
+      const glob = new Bun.Glob(pattern);
+      const files: string[] = [];
+      let truncated = false;
+
+      for await (const match of glob.scan({ cwd: resolved, dot: false, onlyFiles: true })) {
+        if (match.includes("node_modules")) continue;
+        if (files.length >= MAX_RESULTS) {
+          truncated = true;
+          break;
+        }
+        files.push(relative(cwd, resolve(resolved, match)));
+      }
+
+      files.sort();
+      return { files, ...(truncated ? { truncated: true } : {}) };
+    }
+    case "grep": {
+      const { pattern, path, include } = toolInputSchemas.grep.parse(input);
+      const { cwd, resolved } = resolveInsideCwd(path);
+      const args = [
+        "-rn",
+        "--color=never",
+        "--exclude-dir=node_modules",
+        "--exclude-dir=.git",
+        "-E",
+      ];
+      if (include) args.push(`--include=${include}`);
+      args.push(pattern, resolved);
+
+      const proc = Bun.spawn(["grep", ...args], { cwd, stdout: "pipe", stderr: "pipe" });
+      const [stdout, stderr] = await Promise.all([
+        new Response(proc.stdout).text(),
+        new Response(proc.stderr).text(),
+      ]);
+      const exitCode = await proc.exited;
+
+      if (exitCode !== 0 && exitCode !== 1) throw new Error(`grep failed: ${stderr.trim()}`);
+      if (!stdout.trim()) return { matches: [], message: "No matches found" };
+
+      const lines = stdout.trim().split("\n");
+      const matches: { file: string; line: number; content: string }[] = [];
+      let truncated = false;
+
+      for (const line of lines) {
+        if (matches.length >= MAX_MATCHES) {
+          truncated = true;
+          break;
+        }
+        const match = line.match(/^(.+?):(\d+):(.*)$/);
+        if (match) {
+          matches.push({
+            file: relative(cwd, match[1]!),
+            line: Number(match[2]),
+            content: match[3]!,
+          });
+        }
+      }
+
+      return { matches, ...(truncated ? { truncated: true, totalMatches: lines.length } : {}) };
+    }
+    case "writeFile": {
+      const { path, content } = toolInputSchemas.writeFile.parse(input);
+      const { cwd, resolved } = resolveInsideCwd(path);
+      await mkdir(dirname(resolved), { recursive: true });
+      await writeFile(resolved, content, "utf-8");
+      return {
+        success: true as const,
+        path: relative(cwd, resolved),
+        bytesWritten: Buffer.byteLength(content, "utf-8"),
+      };
+    }
+    case "editFile": {
+      const { path, oldString, newString } = toolInputSchemas.editFile.parse(input);
+      const { cwd, resolved } = resolveInsideCwd(path);
+      const content = await readFile(resolved, "utf-8");
+      const occurrences = content.split(oldString).length - 1;
+
+      if (occurrences === 0) throw new Error("oldString not found in file");
+      if (occurrences > 1) throw new Error(`oldString is ambiguous; found ${occurrences} matches`);
+
+      await writeFile(resolved, content.replace(oldString, newString), "utf-8");
+      return { success: true as const, path: relative(cwd, resolved) };
+    }
+    case "bash": {
+      const { command, timeout = DEFAULT_TIMEOUT } = toolInputSchemas.bash.parse(input);
+      const proc = Bun.spawn(["bash", "-c", command], {
+        cwd: resolveInsideCwd(".").resolved,
+        stdout: "pipe",
+        stderr: "pipe",
+        env: { ...process.env, TERM: "dumb" },
+      });
+      const timer = setTimeout(() => proc.kill(), timeout);
+      const [stdout, stderr] = await Promise.all([
+        new Response(proc.stdout).text(),
+        new Response(proc.stderr).text(),
+      ]);
+      const exitCode = await proc.exited;
+      clearTimeout(timer);
+      return {
+        stdout: truncate(stdout, MAX_OUTPUT),
+        stderr: truncate(stderr, MAX_OUTPUT),
+        exitCode,
+      };
+    }
+    default:
+      throw new Error(`Unknown tool: ${toolName}`);
+  }
+};

package/src/lib/oauth.ts

@@ -0,0 +1,166 @@
+import open from "open";
+import { saveAuth } from "./auth";
+
+const LOGIN_TIMEOUT_MS = 5 * 60 * 1000;
+
+type OAuthState = {
+  nonce: string;
+  port: number;
+};
+
+function toBase64Url(input: Uint8Array | string) {
+  return Buffer.from(input).toString("base64url");
+}
+
+async function createPkceChallenge(verifier: string) {
+  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(verifier));
+  return toBase64Url(new Uint8Array(digest));
+}
+
+function encodeState(state: OAuthState) {
+  return toBase64Url(JSON.stringify(state));
+}
+
+function decodeState(state: string) {
+  const [encoded] = state.split(".");
+  if (!encoded) {
+    throw new Error("Invalid state");
+  }
+
+  return JSON.parse(Buffer.from(encoded, "base64url").toString()) as OAuthState;
+}
+
+function getErrorMessage(error: unknown) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+export async function performLogin() {
+  const clerkFrontendApi = process.env.CLERK_FRONTEND_API;
+  const clientId = process.env.CLERK_OAUTH_CLIENT_ID;
+  const clientSecret = process.env.CLERK_OAUTH_CLIENT_SECRET;
+  const apiUrl = process.env.API_URL ?? "http://localhost:3000";
+
+  if (!clerkFrontendApi) throw new Error("CLERK_FRONTEND_API not set");
+  if (!clientId) throw new Error("CLERK_OAUTH_CLIENT_ID not set");
+
+  const nonce = crypto.randomUUID();
+  const codeVerifier = toBase64Url(crypto.getRandomValues(new Uint8Array(32)));
+  const codeChallenge = await createPkceChallenge(codeVerifier);
+
+  let settled = false;
+
+  return new Promise<{ token: string }>((resolve, reject) => {
+    const server = Bun.serve({
+      port: 0,
+      async fetch(req) {
+        const url = new URL(req.url);
+
+        if (url.pathname !== "/callback") {
+          return new Response("Not found", { status: 404 });
+        }
+
+        const error = url.searchParams.get("error");
+
+        if (error) {
+          const msg = url.searchParams.get("error_description") ?? error;
+          settled = true;
+          reject(new Error(msg));
+          setTimeout(() => server.stop(), 500);
+          return new Response(`Authentication failed: ${msg}`, { status: 400 });
+        }
+
+        const code = url.searchParams.get("code");
+        const state = url.searchParams.get("state");
+
+        if (!code || !state) {
+          settled = true;
+          reject(new Error("Missing code or state"));
+          setTimeout(() => server.stop(), 500);
+          return new Response("Bad request", { status: 400 });
+        }
+
+        try {
+          const payload = decodeState(state);
+
+          if (payload.nonce !== nonce) throw new Error("State mismatch");
+        } catch (err) {
+          settled = true;
+          reject(err);
+          setTimeout(() => server.stop(), 500);
+          return new Response("Invalid state", { status: 400 });
+        }
+
+        try {
+          const redirectUri = `${apiUrl}/auth/callback`;
+
+          const tokenParams: Record<string, string> = {
+            grant_type: "authorization_code",
+            code,
+            redirect_uri: redirectUri,
+            client_id: clientId,
+            code_verifier: codeVerifier,
+          };
+          if (clientSecret) {
+            tokenParams.client_secret = clientSecret;
+          }
+
+          const tokenRes = await fetch(`${clerkFrontendApi}/oauth/token`, {
+            method: "POST",
+            headers: { "Content-Type": "application/x-www-form-urlencoded" },
+            body: new URLSearchParams(tokenParams),
+          });
+
+          if (!tokenRes.ok) {
+            const details = await tokenRes.text();
+            throw new Error(details || "Failed to exchange authorization code");
+          }
+
+          const tokenData = (await tokenRes.json()) as { access_token: string };
+
+          settled = true;
+          saveAuth({ token: tokenData.access_token });
+          resolve({ token: tokenData.access_token });
+          setTimeout(() => server.stop(), 500);
+          return new Response("Authenticated! You can close this tab.");
+        } catch (err) {
+          settled = true;
+          reject(err);
+          const message = getErrorMessage(err);
+          setTimeout(() => server.stop(), 500);
+          return new Response(`Authentication failed: ${message}`, { status: 400 });
+        }
+      },
+    });
+
+    // Build state with port and nonce
+    const port = server.port;
+    if (typeof port !== "number") {
+      server.stop();
+      reject(new Error("Failed to start callback server"));
+      return;
+    }
+
+    const state = encodeState({ port, nonce });
+    const redirectUri = `${apiUrl}/auth/callback`;
+
+    const authorizeUrl = new URL(`${clerkFrontendApi}/oauth/authorize`);
+    authorizeUrl.searchParams.set("response_type", "code");
+    authorizeUrl.searchParams.set("client_id", clientId);
+    authorizeUrl.searchParams.set("redirect_uri", redirectUri);
+    authorizeUrl.searchParams.set("scope", "openid email profile");
+    authorizeUrl.searchParams.set("state", state);
+    authorizeUrl.searchParams.set("prompt", "login");
+    authorizeUrl.searchParams.set("code_challenge", codeChallenge);
+    authorizeUrl.searchParams.set("code_challenge_method", "S256");
+
+    void open(authorizeUrl.toString());
+
+    setTimeout(() => {
+      if (!settled) {
+        settled = true;
+        server.stop();
+        reject(new Error("Login timed out"));
+      }
+    }, LOGIN_TIMEOUT_MS)
+  });
+}

package/src/lib/upgrade.ts

@@ -0,0 +1,27 @@
+import open from "open";
+import { apiClient } from "./api-client";
+import { getErrorMessage } from "./http-errors";
+
+export async function openUpgradeCheckout() {
+  const response = await apiClient.billing.checkout.$post();
+
+  if (response.ok) {
+    const data = await response.json();
+    await open(data.url);
+    return;
+  }
+
+  throw new Error(await getErrorMessage(response));
+};
+
+export async function openBillingPortal() {
+  const response = await apiClient.billing.portal.$post();
+
+  if (response.ok) {
+    const data = await response.json();
+    await open(data.url);
+    return;
+  }
+
+  throw new Error(await getErrorMessage(response));
+};

package/src/providers/dialog/index.tsx

@@ -0,0 +1,123 @@
+import { createContext, useContext, useState, useCallback } from "react";
+import type { ReactNode } from "react";
+import { TextAttributes, RGBA } from "@opentui/core";
+import { useKeyboard, useTerminalDimensions } from "@opentui/react";
+import type { DialogConfig } from "./types";
+import { useKeyboardLayer } from "../keyboard-layer";
+import { useTheme } from "../theme";
+
+export type DialogContextValue = {
+  open: (config: DialogConfig) => void;
+  close: () => void;
+};
+
+const DialogContext = createContext<DialogContextValue | null>(null);
+
+export function useDialog(): DialogContextValue {
+  const value = useContext(DialogContext);
+  if (!value) {
+    throw new Error("useDialog must be used within a DialogProvider");
+  }
+  return value;
+};
+
+type DialogProviderProps = {
+  children: ReactNode;
+};
+
+export function DialogProvider({ children }: DialogProviderProps) {
+  const [currentDialog, setCurrentDialog] = useState<DialogConfig | null>(null);
+  const { push, pop } = useKeyboardLayer();
+
+  const close = useCallback(() => {
+    setCurrentDialog(null);
+    pop("dialog");
+  }, [pop]);
+
+  const open = useCallback(
+    (config: DialogConfig) => {
+      setCurrentDialog(config);
+      push("dialog", () => {
+        close();
+        return true;
+      });
+    },
+    [push, close],
+  );
+
+  const value: DialogContextValue = {
+    open,
+    close,
+  };
+
+  return (
+    <DialogContext.Provider value={value}>
+      {children}
+      <Dialog currentDialog={currentDialog} close={close} />
+    </DialogContext.Provider>
+  );
+};
+
+type DialogProps = {
+  currentDialog: DialogConfig | null;
+  close: () => void;
+};
+
+function Dialog({ currentDialog, close }: DialogProps) {
+  const { isTopLayer } = useKeyboardLayer();
+  const dimensions = useTerminalDimensions();
+  const { colors } = useTheme();
+
+  useKeyboard((key) => {
+    if (!currentDialog || !isTopLayer("dialog")) return;
+
+    if (key.name === "escape") {
+      close();
+    }
+  });
+
+  if (!currentDialog) {
+    return null;
+  }
+
+  const { title, children } = currentDialog;
+
+  return (
+    <box
+      position="absolute"
+      left={0}
+      top={0}
+      width={dimensions.width}
+      height={dimensions.height}
+      justifyContent="center"
+      alignItems="center"
+      backgroundColor={RGBA.fromInts(0, 0, 0, 150)}
+      zIndex={100}
+      onMouseDown={() => close()}
+    >
+      <box
+        width={Math.min(60, dimensions.width - 4)}
+        height="auto"
+        backgroundColor={colors.dialogSurface}
+        paddingX={4}
+        paddingY={1}
+        flexDirection="column"
+        gap={1}
+        onMouseDown={(e) => e.stopPropagation()}
+      >
+        <box
+          paddingBottom={1}
+          flexDirection="row"
+          alignItems="center"
+          justifyContent="space-between"
+        >
+          <text attributes={TextAttributes.BOLD}>{title}</text>
+          <text attributes={TextAttributes.DIM} onMouseDown={() => close()}>
+            esc
+          </text>
+        </box>
+        <box flexGrow={1}>{children}</box>
+      </box>
+    </box>
+  );
+};

package/src/providers/dialog/types.ts

@@ -0,0 +1,6 @@
+import type { ReactNode } from "react";
+
+export type DialogConfig = {
+  title: string;
+  children: ReactNode;
+};

package/src/providers/keyboard-layer/index.tsx

@@ -0,0 +1,98 @@
+import React, { 
+  createContext, 
+  useContext, 
+  useState, 
+  useCallback, 
+  useRef
+} from "react";
+import { useKeyboard, useRenderer } from "@opentui/react";
+
+type Responder = () => boolean;
+
+type KeyboardLayerContextValue = {
+  push: (id: string, responder?: Responder) => void;
+  pop: (id: string) => void;
+  isTopLayer: (id: string) => boolean;
+  setResponder: (id: string, responder: Responder | null) => void;
+};
+
+const KeyboardLayerContext = createContext<KeyboardLayerContextValue | null>(null);
+
+export function KeyboardLayerProvider({ children }: { children: React.ReactNode }) {
+  const [stack, setStack] = useState<string[]>(["base"]);
+  const stackRef = useRef(stack);
+  stackRef.current = stack;
+
+  const responders = useRef<Map<string, Responder>>(new Map());
+  const renderer = useRenderer();
+
+  const push = useCallback((id: string, responder?: Responder) => {
+    if (responder) {
+      responders.current.set(id, responder);
+    }
+
+    setStack((prev) => {
+      if (prev.includes(id)) {
+        return prev;
+      }
+
+      return [...prev, id];
+    });
+  }, []);
+
+  const pop = useCallback((id: string) => {
+    responders.current.delete(id);
+    setStack((prev) => prev.filter((layer) => layer !== id));
+  }, []);
+
+  const isTopLayer = useCallback(
+    (id: string) => {
+      return stack.length === 0 || stack[stack.length - 1] === id;
+    },
+    [stack],
+  );
+
+  const setResponder = useCallback((
+    id: string,
+    responder: Responder | null
+  ) => {
+    if (responder) {
+      responders.current.set(id, responder);
+    } else {
+      responders.current.delete(id);
+    }
+  }, []);
+
+  // Single ctrl+c handler that walks the responder chain
+  useKeyboard((key) => {
+    if (!key.ctrl || key.name !== "c") return;
+
+    const currentStack = stackRef.current;
+    for (let i = currentStack.length - 1; i >= 0; i--) {
+      const layerId = currentStack[i]!;
+      const responder = responders.current.get(layerId);
+      if (responder && responder()) {
+        return;
+      }
+    };
+
+    // No responder handled it — exit
+    renderer.destroy();
+  });
+
+  return (
+    <KeyboardLayerContext.Provider 
+      value={{ push, pop, isTopLayer, setResponder }}
+    >
+      {children}
+    </KeyboardLayerContext.Provider>
+  );
+};
+
+export function useKeyboardLayer() {
+  const context = useContext(KeyboardLayerContext);
+  if (!context) {
+    throw new Error("useKeyboardLayer must be used within a KeyboardLayerProvider");
+  }
+  return context;
+};

package/src/providers/prompt-config/index.tsx

@@ -0,0 +1,52 @@
+import { createContext, useContext, useState, useCallback } from "react";
+import type { ReactNode } from "react";
+import { 
+  DEFAULT_CHAT_MODEL_ID, 
+  Mode,
+  type ModeType,
+  type SupportedChatModelId,
+} from "@nightcode/shared";
+
+type PromptConfigContextValue = {
+  mode: ModeType;
+  toggleMode: () => void;
+  setMode: (mode: ModeType) => void;
+  model: SupportedChatModelId;
+  setModel: (model: SupportedChatModelId) => void;
+};
+
+const PromptConfigContext = createContext<PromptConfigContextValue | null>(null);
+
+export function usePromptConfig(): PromptConfigContextValue {
+  const value = useContext(PromptConfigContext);
+  if (!value) {
+    throw new Error("usePromptConfig must be used within a PromptConfigProvider");
+  }
+  return value;
+};
+
+type PromptConfigProviderProps = {
+  children: ReactNode;
+};
+
+export function PromptConfigProvider({ children }: PromptConfigProviderProps) {
+  const [mode, setMode] = useState<ModeType>(Mode.BUILD);
+  const [model, setModel] = useState<SupportedChatModelId>(DEFAULT_CHAT_MODEL_ID);
+
+  const toggleMode = useCallback(() => {
+    setMode((m) => (m === Mode.BUILD ? Mode.PLAN : Mode.BUILD));
+  }, []);
+
+  return (
+    <PromptConfigContext.Provider 
+      value={{ 
+        mode, 
+        toggleMode, 
+        setMode, 
+        model, 
+        setModel
+    }}>
+      {children}
+    </PromptConfigContext.Provider>
+  );
+};