indusagi-coding-agent 0.2.5 → 0.2.9

package/src/launch/oauth.ts

@@ -0,0 +1,203 @@
+/**
+ * OAuth integration — the browser-sign-in counterpart to the api-key flow.
+ */
+import { spawn } from "node:child_process";
+import {
+  anthropicOAuthProvider,
+  getOAuthProvider,
+  getOAuthProviders,
+  githubCopilotOAuthProvider,
+  openaiCodexOAuthProvider,
+  registerOAuthProvider,
+  type OAuthLoginCallbacks,
+} from "indusagi/ai";
+import type { AuthVault } from "./contract.js";
+import { SERVER_TIER_PROVIDER_ID, runServerTierLogin } from "./login.js";
+
+const BUILT_IN_OAUTH: { provider: { id: string; name: string }; label: string }[] = [
+  { provider: anthropicOAuthProvider, label: "Anthropic (Claude sign-in)" },
+  { provider: openaiCodexOAuthProvider, label: "OpenAI (ChatGPT sign-in)" },
+  { provider: githubCopilotOAuthProvider, label: "GitHub Copilot" },
+];
+
+const OAUTH_LABELS: Record<string, string> = Object.fromEntries(
+  BUILT_IN_OAUTH.map((entry) => [entry.provider.id, entry.label]),
+);
+
+/**
+ * Register the framework's built-in sign-in providers, idempotently.
+ */
+export function registerBuiltInOAuthProviders(): string[] {
+  for (const { provider } of BUILT_IN_OAUTH) {
+    if (getOAuthProvider(provider.id) === undefined) {
+      registerOAuthProvider(provider);
+    }
+  }
+  return getOAuthProviders().map((provider) => provider.id);
+}
+
+registerBuiltInOAuthProviders();
+
+const OAUTH_CLIENT_ID_WIRING: Record<string, { envVar: string; sentinel: string }> = {
+  anthropic: {
+    envVar: "INDUSAGI_ANTHROPIC_OAUTH_CLIENT_ID",
+    sentinel: "<UNREGISTERED-ANTHROPIC-OAUTH-APP>",
+  },
+  "github-copilot": {
+    envVar: "INDUSAGI_GITHUB_COPILOT_CLIENT_ID",
+    sentinel: "<UNREGISTERED-COPILOT-APP>",
+  },
+};
+
+/**
+ * Whether a registered sign-in provider has a *real* OAuth client id wired in.
+ */
+export function hasRegisteredOAuthClientId(providerId: string): boolean {
+  const wiring = OAUTH_CLIENT_ID_WIRING[providerId];
+  if (wiring === undefined) return true;
+  const value = process.env[wiring.envVar];
+  return value !== undefined && value.length > 0 && value !== wiring.sentinel;
+}
+
+function oauthClientIdEnvVar(providerId: string): string | undefined {
+  return OAUTH_CLIENT_ID_WIRING[providerId]?.envVar;
+}
+
+export type AuthKind = "oauth" | "apiKey";
+
+export interface LoginProvider {
+  readonly id: string;
+  readonly label: string;
+  readonly authKind: AuthKind;
+}
+
+interface ProviderDirectoryEntry {
+  readonly id: string;
+  readonly label: string;
+  readonly envKey: string;
+  readonly docsUrl: string;
+}
+
+import { PROVIDER_DIRECTORY } from "./credentials.js";
+
+/**
+ * The merged sign-in directory.
+ */
+export function listLoginProviders(): LoginProvider[] {
+  const serverTier: LoginProvider = {
+    id: SERVER_TIER_PROVIDER_ID,
+    label: "Indus Server (sign in for server-tier model access)",
+    authKind: "oauth",
+  };
+  const oauth = getOAuthProviders().map((provider) => ({
+    id: provider.id,
+    label: OAUTH_LABELS[provider.id] ?? provider.name,
+    authKind: "oauth" as const,
+  }));
+  const apiKey = (PROVIDER_DIRECTORY as readonly ProviderDirectoryEntry[]).map((entry) => ({
+    id: String(entry.id),
+    label: entry.label,
+    authKind: "apiKey" as const,
+  }));
+  return [serverTier, ...oauth, ...apiKey];
+}
+
+function isWebUrl(url: string): boolean {
+  try {
+    const parsed = new URL(url);
+    return parsed.protocol === "http:" || parsed.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+
+interface LaunchAttempt {
+  command: string;
+  args: string[];
+}
+
+export function launchAttempts(url: string, platform: NodeJS.Platform = process.platform): LaunchAttempt[] {
+  switch (platform) {
+    case "darwin":
+      return [{ command: "open", args: [url] }];
+    case "win32":
+      return [{ command: "rundll32.exe", args: ["url.dll,FileProtocolHandler", url] }];
+    default:
+      return [
+        { command: "xdg-open", args: [url] },
+        { command: "x-www-browser", args: [url] },
+        { command: "google-chrome", args: [url] },
+        { command: "chromium", args: [url] },
+      ];
+  }
+}
+
+/**
+ * Open a sign-in url in the user's default browser.
+ */
+export function openLoginUrl(url: string): Promise<boolean> {
+  if (!isWebUrl(url)) return Promise.resolve(false);
+  const attempts = launchAttempts(url);
+  const tryAt = (index: number): Promise<boolean> => {
+    if (index >= attempts.length) return Promise.resolve(false);
+    const { command, args } = attempts[index];
+    return new Promise<boolean>((resolve) => {
+      let settled = false;
+      const finish = (ok: boolean): void => {
+        if (settled) return;
+        settled = true;
+        resolve(ok);
+      };
+      try {
+        const child = spawn(command, [...args], {
+          stdio: "ignore",
+          windowsHide: true,
+        });
+        child.once("error", () => finish(false));
+        child.once("spawn", () => {
+          child.unref();
+          finish(true);
+        });
+      } catch {
+        finish(false);
+      }
+    }).then((ok) => (ok ? true : tryAt(index + 1)));
+  };
+  return tryAt(0);
+}
+
+export interface OAuthLoginResult {
+  readonly provider: string;
+  readonly account: string;
+  readonly madeDefault: boolean;
+}
+
+/**
+ * Drive a framework provider's browser sign-in and persist the result.
+ */
+export async function startOAuthLogin(
+  providerId: string,
+  callbacks: OAuthLoginCallbacks,
+  vault: AuthVault,
+  account: string = "default",
+): Promise<OAuthLoginResult> {
+  if (providerId === SERVER_TIER_PROVIDER_ID) {
+    await runServerTierLogin(callbacks);
+    return { provider: providerId, account, madeDefault: true };
+  }
+  const provider = getOAuthProvider(providerId);
+  if (provider === undefined) {
+    throw new Error(`No browser sign-in is available for "${providerId}".`);
+  }
+  if (!hasRegisteredOAuthClientId(providerId)) {
+    const envVar = oauthClientIdEnvVar(providerId);
+    const hint =
+      envVar !== undefined ? `set ${envVar} and restart` : "configure its OAuth client id";
+    throw new Error(`Browser sign-in for "${providerId}" is not configured: ${hint}.`);
+  }
+  const credentials = await provider.login(callbacks);
+  const existing = await vault.listAccounts(providerId);
+  const madeDefault = existing.length === 0;
+  await vault.putOAuth(providerId, account, credentials, madeDefault);
+  return { provider: providerId, account, madeDefault };
+}

package/src/launch/packages.ts

@@ -0,0 +1,194 @@
+/**
+ * Package command — `runPackageCommand`.
+ *
+ * The top-level `install` / `remove` / `update` / `list` / `config` surface that
+ * manages the extension-package sources the launcher loads.
+ */
+import type { PreferenceStore } from "../settings/index.js";
+
+export type PackageCommand = "install" | "remove" | "update" | "list" | "config";
+
+export const PACKAGE_COMMANDS: readonly PackageCommand[] = [
+  "install",
+  "remove",
+  "update",
+  "list",
+  "config",
+];
+
+export interface PackageIo {
+  print(line: string): void;
+  printError(line: string): void;
+}
+
+export function defaultPackageIo(): PackageIo {
+  return {
+    print(line: string): void {
+      process.stdout.write(line.endsWith("\n") ? line : `${line}\n`);
+    },
+    printError(line: string): void {
+      process.stderr.write(line.endsWith("\n") ? line : `${line}\n`);
+    },
+  };
+}
+
+export interface PackageCommandOptions {
+  readonly store: PreferenceStore;
+  readonly io?: PackageIo;
+}
+
+export interface PackageResult {
+  readonly handled: boolean;
+  readonly command?: PackageCommand;
+  readonly code?: number;
+}
+
+const PACKAGES_KEY = "extensionPackages";
+
+function asPackageCommand(token: string | undefined): PackageCommand | undefined {
+  return token !== undefined && (PACKAGE_COMMANDS as readonly string[]).includes(token)
+    ? (token as PackageCommand)
+    : undefined;
+}
+
+function sourceKey(source: string): string {
+  const trimmed = source.trim();
+  if (trimmed.startsWith("npm:")) {
+    const spec = trimmed.slice("npm:".length);
+    const at = spec.lastIndexOf("@");
+    const name = at > 0 ? spec.slice(0, at) : spec;
+    return `npm:${name}`;
+  }
+  const gitlike =
+    trimmed.startsWith("git:") ||
+    trimmed.startsWith("http://") ||
+    trimmed.startsWith("https://");
+  if (gitlike) {
+    const withoutScheme = trimmed.replace(/^git:/, "").replace(/^https?:\/\//, "");
+    const withoutVersion = withoutScheme.split("@")[0] ?? withoutScheme;
+    return `git:${withoutVersion.replace(/\.git$/, "")}`;
+  }
+  return `local:${trimmed}`;
+}
+
+function sourcesMatch(a: string, b: string): boolean {
+  return sourceKey(a) === sourceKey(b);
+}
+
+function readSources(store: PreferenceStore): string[] {
+  const value = store.get(PACKAGES_KEY);
+  return Array.isArray(value) ? [...value] : [];
+}
+
+function writeSources(store: PreferenceStore, sources: string[]): void {
+  store.set(PACKAGES_KEY, sources);
+  store.save();
+}
+
+function readSource(rest: readonly string[]): string | undefined {
+  return rest.find((token) => !token.startsWith("-"));
+}
+
+function doInstall(
+  rest: readonly string[],
+  store: PreferenceStore,
+  io: PackageIo,
+): PackageResult {
+  const source = readSource(rest);
+  if (source === undefined) {
+    io.printError(
+      "install: a package source is required (npm:, git:, https:, or a local path).",
+    );
+    return { handled: true, command: "install", code: 1 };
+  }
+  const sources = readSources(store);
+  if (sources.some((existing) => sourcesMatch(existing, source))) {
+    io.print(`Already installed: ${source}`);
+    return { handled: true, command: "install", code: 0 };
+  }
+  writeSources(store, [...sources, source]);
+  io.print(`Installed ${source}`);
+  return { handled: true, command: "install", code: 0 };
+}
+
+function doRemove(
+  rest: readonly string[],
+  store: PreferenceStore,
+  io: PackageIo,
+): PackageResult {
+  const source = readSource(rest);
+  if (source === undefined) {
+    io.printError("remove: a package source is required.");
+    return { handled: true, command: "remove", code: 1 };
+  }
+  const sources = readSources(store);
+  const next = sources.filter((existing) => !sourcesMatch(existing, source));
+  if (next.length === sources.length) {
+    io.printError(`remove: not installed: ${source}`);
+    return { handled: true, command: "remove", code: 1 };
+  }
+  writeSources(store, next);
+  io.print(`Removed ${source}`);
+  return { handled: true, command: "remove", code: 0 };
+}
+
+function doUpdate(store: PreferenceStore, io: PackageIo): PackageResult {
+  store.reload();
+  const sources = readSources(store);
+  if (sources.length === 0) {
+    io.print("No packages to update.");
+    return { handled: true, command: "update", code: 0 };
+  }
+  io.print(`Refreshed ${sources.length} package source${sources.length === 1 ? "" : "s"}.`);
+  for (const source of sources) {
+    io.print(`  ${source}`);
+  }
+  return { handled: true, command: "update", code: 0 };
+}
+
+function doList(store: PreferenceStore, io: PackageIo): PackageResult {
+  const sources = readSources(store);
+  if (sources.length === 0) {
+    io.print("No packages installed.");
+    return { handled: true, command: "list", code: 0 };
+  }
+  io.print("Installed packages:");
+  for (const source of sources) {
+    io.print(`  ${source}`);
+  }
+  return { handled: true, command: "list", code: 0 };
+}
+
+function doConfig(store: PreferenceStore, io: PackageIo): PackageResult {
+  const locations = store.paths();
+  io.print(`Global settings: ${locations.global}`);
+  io.print(`Project settings: ${locations.project}`);
+  io.print("Resolved settings:");
+  io.print(JSON.stringify(store.snapshot(), null, 2));
+  return { handled: true, command: "config", code: 0 };
+}
+
+/**
+ * Run the package command.
+ */
+export async function runPackageCommand(
+  argv: readonly string[],
+  opts: PackageCommandOptions,
+): Promise<PackageResult> {
+  const command = asPackageCommand(argv[0]);
+  if (command === undefined) return { handled: false };
+  const io = opts.io ?? defaultPackageIo();
+  const rest = argv.slice(1);
+  switch (command) {
+    case "install":
+      return doInstall(rest, opts.store, io);
+    case "remove":
+      return doRemove(rest, opts.store, io);
+    case "update":
+      return doUpdate(opts.store, io);
+    case "list":
+      return doList(opts.store, io);
+    case "config":
+      return doConfig(opts.store, io);
+  }
+}

package/src/launch/pickers.ts

@@ -0,0 +1,189 @@
+/**
+ * Launch pickers — `pickResumeTarget` and `browseSettings`.
+ */
+import { createInterface } from "node:readline/promises";
+import { createElement } from "indusagi/react-host";
+import { render } from "indusagi/react-host/ink";
+import { StartupSessionPicker } from "indusagi/react-ink";
+import type {
+  ResumeFault,
+  ResumeRef,
+  SessionLoader,
+  SettingsBrowseOptions,
+} from "./contract.js";
+
+export interface ResumeDeps {
+  isInteractive(): boolean;
+  mountPicker(sessions: readonly ResumeRef[], totalCount: number): Promise<ResumeRef | null>;
+}
+
+/**
+ * The live {@link ResumeDeps}: a real TTY probe and the Ink picker mount.
+ */
+export function defaultResumeDeps(): ResumeDeps {
+  return {
+    isInteractive(): boolean {
+      return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+    },
+    mountPicker(sessions, totalCount): Promise<ResumeRef | null> {
+      const byPath = new Map(sessions.map((s) => [s.path, s]));
+      return new Promise<ResumeRef | null>((resolve, reject) => {
+        let settled = false;
+        const settle = (value: ResumeRef | null): void => {
+          if (settled) return;
+          settled = true;
+          instance.unmount();
+          resolve(value);
+        };
+        let instance: { unmount: () => void; waitUntilExit: () => Promise<void> };
+        try {
+          instance = render(
+            createElement(StartupSessionPicker, {
+              sessions: [...sessions],
+              totalCount,
+              onClose: () => settle(null),
+              onSelect: (session: ResumeRef) => settle(byPath.get(session.path) ?? null),
+            }),
+          );
+        } catch (cause) {
+          reject(cause);
+          return;
+        }
+        void instance.waitUntilExit().then(() => {
+          if (!settled) {
+            settled = true;
+            resolve(null);
+          }
+        });
+      });
+    },
+  };
+}
+
+/**
+ * Merge two session lists into one newest-first list de-duplicated by path.
+ */
+export function mergeSessions(
+  current: readonly ResumeRef[],
+  all: readonly ResumeRef[],
+): ResumeRef[] {
+  const byPath = new Map<string, ResumeRef>();
+  for (const session of [...current, ...all]) {
+    if (!byPath.has(session.path)) byPath.set(session.path, session);
+  }
+  return [...byPath.values()].sort((a, b) => b.lastModified - a.lastModified);
+}
+
+export interface ResumeOutcome {
+  readonly path: string | null;
+  readonly fault?: ResumeFault;
+}
+
+/**
+ * Choose a session to resume.
+ */
+export async function pickResumeTarget(
+  loadCurrent: SessionLoader,
+  loadAll: SessionLoader,
+  deps: ResumeDeps = defaultResumeDeps(),
+): Promise<ResumeOutcome> {
+  let current: ResumeRef[];
+  let all: ResumeRef[];
+  try {
+    [current, all] = await Promise.all([loadCurrent(), loadAll()]);
+  } catch (cause) {
+    return {
+      path: null,
+      fault: {
+        message: "Failed to load resumable sessions.",
+        cause,
+      },
+    };
+  }
+  const sessions = mergeSessions(current, all);
+  if (sessions.length === 0) return { path: null };
+  if (!deps.isInteractive()) {
+    return { path: sessions[0].path };
+  }
+  try {
+    const chosen = await deps.mountPicker(sessions, sessions.length);
+    return { path: chosen === null ? null : chosen.path };
+  } catch (cause) {
+    return {
+      path: null,
+      fault: {
+        message: "The session picker failed to start.",
+        cause,
+      },
+    };
+  }
+}
+
+export interface SettingsBrowseIo {
+  print(line: string): void;
+  pause(prompt: string): Promise<void>;
+}
+
+export function defaultSettingsBrowseIo(): SettingsBrowseIo {
+  return {
+    print(line: string): void {
+      process.stdout.write(line.endsWith("\n") ? line : `${line}\n`);
+    },
+    async pause(prompt: string): Promise<void> {
+      const rl = createInterface({ input: process.stdin, output: process.stdout });
+      try {
+        await rl.question(prompt);
+      } finally {
+        rl.close();
+      }
+    },
+  };
+}
+
+function renderSection(title: string, paths: readonly string[]): string[] {
+  if (paths.length === 0) return [`${title}: (none)`];
+  return [`${title}:`, ...paths.map((path) => `  - ${path}`)];
+}
+
+/**
+ * Build the entire settings listing as an array of lines.
+ */
+export function renderSettingsListing(opts: SettingsBrowseOptions): string[] {
+  const lines: string[] = [];
+  lines.push("Configuration");
+  lines.push(`  Working directory: ${opts.cwd}`);
+  lines.push(`  Profile directory: ${opts.profileDir}`);
+  lines.push("");
+  lines.push("Settings");
+  lines.push(`  Default model: ${opts.settings.defaultModel ?? "(unset)"}`);
+  lines.push(
+    `  System prompt: ${opts.settings.systemPrompt !== undefined ? "(custom)" : "(default)"}`,
+  );
+  const serverCount = opts.settings.mcpServers?.length ?? 0;
+  lines.push(`  MCP servers: ${serverCount}`);
+  lines.push("");
+  const categories = Object.keys(opts.resolvedPaths).sort();
+  if (categories.length === 0) {
+    lines.push("Resources: (none discovered)");
+  } else {
+    lines.push("Resources");
+    for (const category of categories) {
+      for (const line of renderSection(`  ${category}`, opts.resolvedPaths[category])) {
+        lines.push(line);
+      }
+    }
+  }
+  return lines;
+}
+
+/**
+ * Print the settings / resource listing and wait for the user to dismiss it.
+ */
+export async function browseSettings(
+  opts: SettingsBrowseOptions,
+  io: SettingsBrowseIo = defaultSettingsBrowseIo(),
+): Promise<void> {
+  for (const line of renderSettingsListing(opts)) io.print(line);
+  io.print("");
+  await io.pause("Press Enter to continue. ");
+}

package/src/runtime-bridge/bridges/_drive.ts

@@ -0,0 +1,96 @@
+/**
+ * Shared exchange driver — the transport-wiring half every bridge reuses.
+ */
+import type {
+  Api,
+  AssistantMessageEventStream,
+  BridgeEventSink,
+  ChildMessage,
+  ChildRequest,
+  ChildTransport,
+  ExchangeOptions,
+  Model,
+} from "../contract.js";
+import { createBridgeSink, type BridgeMessageSeed } from "../sink.js";
+
+export type ParseStep = { readonly status: "continue" } | { readonly status: "done" };
+
+export type ChildParser = (message: ChildMessage, sink: BridgeEventSink) => ParseStep;
+
+export function seedFromModel(model: Model<Api>): BridgeMessageSeed {
+  return { api: model.api, provider: model.provider, model: model.id };
+}
+
+export function errorText(cause: unknown): string {
+  if (cause instanceof Error) return cause.message;
+  if (typeof cause === "string") return cause;
+  return "external runtime error";
+}
+
+export function asRecord(value: unknown): Record<string, unknown> | undefined {
+  return typeof value === "object" && value !== null
+    ? (value as Record<string, unknown>)
+    : undefined;
+}
+
+export function strField(record: Record<string, unknown>, key: string): string | undefined {
+  const value = record[key];
+  return typeof value === "string" ? value : undefined;
+}
+
+export function driveExchange(
+  model: Model<Api>,
+  opts: ExchangeOptions,
+  transport: ChildTransport,
+  request: ChildRequest,
+  parse: ChildParser,
+): AssistantMessageEventStream {
+  const sink = createBridgeSink(seedFromModel(model));
+  let finished = false;
+  let unsubscribe: (() => void) | undefined;
+
+  const teardown = (): void => {
+    unsubscribe?.();
+    unsubscribe = undefined;
+    void transport.close().catch(() => undefined);
+  };
+
+  const settleSuccess = (): void => {
+    if (finished) return;
+    finished = true;
+    sink.finishSuccess();
+    teardown();
+  };
+
+  const settleError = (message: string, aborted: boolean, cause?: unknown): void => {
+    if (finished) return;
+    finished = true;
+    sink.finishError({ message, aborted, cause });
+    teardown();
+  };
+
+  const signal = opts.signal;
+  if (signal) {
+    if (signal.aborted) {
+      queueMicrotask(() => settleError("exchange aborted", true));
+      return sink.stream;
+    }
+    signal.addEventListener("abort", () => settleError("exchange aborted", true), { once: true });
+  }
+
+  unsubscribe = transport.onMessage((message) => {
+    if (finished) return;
+    try {
+      const step = parse(message, sink);
+      if (step.status === "done") settleSuccess();
+    } catch (cause) {
+      settleError(errorText(cause), false, cause);
+    }
+  });
+
+  void transport.send(request).catch((cause) => {
+    settleError(errorText(cause), false, cause);
+  });
+
+  return sink.stream;
+}