conductor-oss 0.3.3 → 0.4.0

package/web/.next/standalone/packages/web/src/lib/remoteAuth.ts

@@ -1,47 +1,12 @@
-const BUILTIN_REMOTE_ACCESS_TOKEN_ENV = "CONDUCTOR_REMOTE_ACCESS_TOKEN";
-const BUILTIN_REMOTE_SESSION_SECRET_ENV = "CONDUCTOR_REMOTE_SESSION_SECRET";
-
 export const BUILTIN_REMOTE_SESSION_COOKIE = "conductor_session";
 export const BUILTIN_REMOTE_SESSION_TTL_SECONDS = 60 * 60 * 24 * 7;
 
-function getAccessToken(): string | null {
-  const token = process.env[BUILTIN_REMOTE_ACCESS_TOKEN_ENV]?.trim();
-  return token && token.length > 0 ? token : null;
-}
-
-function getSessionSecret(): string | null {
-  const secret = process.env[BUILTIN_REMOTE_SESSION_SECRET_ENV]?.trim();
-  return secret && secret.length > 0 ? secret : null;
-}
-
-function toHex(bytes: Uint8Array): string {
-  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
-}
-
-function constantTimeEqual(left: string, right: string): boolean {
-  if (left.length !== right.length) return false;
-  let mismatch = 0;
-  for (let index = 0; index < left.length; index += 1) {
-    mismatch |= left.charCodeAt(index) ^ right.charCodeAt(index);
-  }
-  return mismatch === 0;
-}
-
-async function signPayload(payload: string, secret: string): Promise<string> {
-  const encoder = new TextEncoder();
-  const key = await crypto.subtle.importKey(
-    "raw",
-    encoder.encode(secret),
-    { name: "HMAC", hash: "SHA-256" },
-    false,
-    ["sign"],
-  );
-  const signature = await crypto.subtle.sign("HMAC", key, encoder.encode(payload));
-  return toHex(new Uint8Array(signature));
+export function getBuiltinRemoteAccessToken(): string | null {
+  return null;
 }
 
 export function isBuiltinRemoteAuthEnabled(): boolean {
-  return Boolean(getAccessToken() && getSessionSecret());
+  return false;
 }
 
 export function sanitizeRedirectTarget(value: string | null | undefined): string {
@@ -52,39 +17,17 @@ export function sanitizeRedirectTarget(value: string | null | undefined): string
 }
 
 export function isValidBuiltinAccessToken(candidate: string | null | undefined): boolean {
-  const configured = getAccessToken();
-  if (!configured || !candidate) return false;
-  return constantTimeEqual(configured, candidate.trim());
+  void candidate;
+  return false;
 }
 
 export async function createBuiltinRemoteSessionValue(): Promise<string> {
-  const secret = getSessionSecret();
-  if (!secret) {
-    throw new Error("Built-in remote session secret is not configured");
-  }
-
-  const expiresAt = Date.now() + BUILTIN_REMOTE_SESSION_TTL_SECONDS * 1000;
-  const payload = String(expiresAt);
-  const signature = await signPayload(payload, secret);
-  return `${payload}.${signature}`;
+  throw new Error("Public share-link remote access has been removed.");
 }
 
 export async function verifyBuiltinRemoteSession(value: string | null | undefined): Promise<boolean> {
-  const secret = getSessionSecret();
-  if (!secret || !value) return false;
-
-  const separator = value.indexOf(".");
-  if (separator <= 0 || separator === value.length - 1) return false;
-
-  const payload = value.slice(0, separator);
-  const signature = value.slice(separator + 1);
-  const expiresAt = Number.parseInt(payload, 10);
-  if (!Number.isFinite(expiresAt) || expiresAt <= Date.now()) {
-    return false;
-  }
-
-  const expected = await signPayload(payload, secret);
-  return constantTimeEqual(expected, signature);
+  void value;
+  return false;
 }
 
 export function getBuiltinRemoteSessionCookieOptions(isSecure: boolean): {

package/web/.next/standalone/packages/web/src/lib/runtimeAgentModels/amp.ts

@@ -0,0 +1,42 @@
+import type { AgentModelAccess } from "@conductor-oss/core/types";
+import type { RuntimeAgentModelCatalog } from "../runtimeAgentModelsShared";
+import {
+  buildDefaultAccessRuntimeCatalog,
+  readCommandHelp,
+  uniqueStringValues,
+} from "./helpers";
+
+function formatAmpModeLabel(mode: string): string {
+  return `Amp ${mode.trim().charAt(0).toUpperCase()}${mode.trim().slice(1)}`;
+}
+
+export async function buildAmpRuntimeModelCatalog(): Promise<RuntimeAgentModelCatalog | null> {
+  const help = await readCommandHelp(["amp"]);
+  if (!help) return null;
+
+  const match = help.match(/Set the agent mode \(([^)]+)\)/i);
+  const modes = uniqueStringValues(match?.[1]
+    ? match[1]
+      .split(",")
+      .map((value) => value.trim().toLowerCase())
+    : []);
+
+  if (modes.length === 0) {
+    return null;
+  }
+
+  const models = modes.map((mode) => ({
+    id: mode,
+    label: formatAmpModeLabel(mode),
+    description: `Amp mode exposed by the local CLI (${mode}).`,
+    access: ["default"] as AgentModelAccess[],
+  }));
+  const defaultMode = modes.includes("smart")
+    ? "smart"
+    : modes[0] ?? null;
+
+  return buildDefaultAccessRuntimeCatalog("amp", models, {
+    customModelPlaceholder: defaultMode,
+    defaultModel: defaultMode,
+  });
+}

package/web/.next/standalone/packages/web/src/lib/runtimeAgentModels/ccr.ts

@@ -0,0 +1,47 @@
+import type {
+  AgentModelOption,
+  AgentReasoningOption,
+} from "@conductor-oss/core/types";
+import type { RuntimeAgentModelCatalog } from "../runtimeAgentModelsShared";
+import {
+  buildDefaultAccessRuntimeCatalog,
+  readCommandOutput,
+  uniqueModelOptions,
+  uniqueReasoningOptions,
+} from "./helpers";
+import { buildClaudeRuntimeModelCatalog } from "./claude";
+
+export async function buildCcrRuntimeModelCatalog(): Promise<RuntimeAgentModelCatalog | null> {
+  const version = await readCommandOutput(["ccr"], ["version"]);
+  if (!version) {
+    return null;
+  }
+
+  const claudeCatalog = await buildClaudeRuntimeModelCatalog();
+  if (!claudeCatalog) {
+    return null;
+  }
+
+  const models = uniqueModelOptions(
+    Object.values(claudeCatalog.modelsByAccess)
+      .flat()
+      .filter((value): value is AgentModelOption => Boolean(value)),
+  );
+  const reasoningOptions = uniqueReasoningOptions(
+    Object.values(claudeCatalog.reasoningOptionsByAccess ?? {})
+      .flat()
+      .filter((value): value is AgentReasoningOption => Boolean(value)),
+  );
+  const defaultModel = Object.values(claudeCatalog.defaultModelByAccess)[0] ?? models[0]?.id ?? null;
+  const defaultReasoning = Object.values(claudeCatalog.defaultReasoningByAccess ?? {})[0] ?? null;
+
+  return buildDefaultAccessRuntimeCatalog("ccr", models, {
+    customModelPlaceholder: claudeCatalog.customModelPlaceholder,
+    defaultModel,
+    modelContextById: claudeCatalog.modelContextById,
+    reasoningOptions,
+    defaultReasoning,
+    reasoningOptionsByModel: claudeCatalog.reasoningOptionsByModel,
+    defaultReasoningByModel: claudeCatalog.defaultReasoningByModel,
+  });
+}

package/web/.next/standalone/packages/web/src/lib/runtimeAgentModels/claude.ts

@@ -0,0 +1,179 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type {
+  AgentModelAccess,
+  AgentModelOption,
+} from "@conductor-oss/core/types";
+import type {
+  RuntimeAgentModelContext,
+  RuntimeAgentModelCatalog,
+} from "../runtimeAgentModelsShared";
+import type { ClaudeSettings, ClaudeStatsCache } from "./types";
+import {
+  buildRuntimeModelContext,
+  detectReasoningOptionsFromHelp,
+  pickRuntimeDefaultReasoning,
+  readJsonFileIfPresent,
+  toObject,
+  toRuntimeModelOption,
+  uniqueModelOptions,
+} from "./helpers";
+
+function formatClaudeModelLabel(model: string): string {
+  const normalized = model.trim().toLowerCase();
+  if (normalized === "opus") return "Claude Opus";
+  if (normalized === "sonnet") return "Claude Sonnet";
+  if (normalized === "haiku") return "Claude Haiku";
+
+  const match = normalized.match(/^claude-(sonnet|opus|haiku)-(\d+)-(\d+)(?:-(\d{8}))?$/);
+  if (!match) {
+    return normalized
+      .split(/[-_]+/g)
+      .filter(Boolean)
+      .map((part) => part[0]?.toUpperCase() + part.slice(1))
+      .join(" ");
+  }
+
+  const family = match[1];
+  const major = match[2];
+  const minor = match[3];
+  return `Claude ${family[0]?.toUpperCase() + family.slice(1)} ${major}.${minor}`;
+}
+
+function getClaudeAccessForModel(model: string): AgentModelAccess[] {
+  const normalized = model.trim().toLowerCase();
+  if (normalized === "opus" || normalized.includes("claude-opus")) {
+    return ["max", "api"];
+  }
+  if (normalized === "haiku" || normalized.includes("claude-haiku")) {
+    return ["pro", "max", "api"];
+  }
+  return ["pro", "max", "api"];
+}
+
+function resolveClaudeConfiguredModel(
+  configuredModel: string | null,
+  availableModels: AgentModelOption[],
+  family: "sonnet" | "opus" | "haiku",
+): string | null {
+  if (!configuredModel) return null;
+  const normalized = configuredModel.trim().toLowerCase();
+  if (availableModels.some((model) => model.id === normalized)) {
+    return normalized;
+  }
+  if (normalized === family) {
+    return availableModels.find((model) => model.id.toLowerCase().includes(`claude-${family}`))?.id ?? null;
+  }
+  return null;
+}
+
+function collectClaudeStatsModels(stats: ClaudeStatsCache | null): string[] {
+  const entries = Array.isArray(stats?.dailyModelTokens) ? stats.dailyModelTokens : [];
+  const seen = new Set<string>();
+  const ordered: string[] = [];
+
+  for (const entry of [...entries].reverse()) {
+    const tokensByModel = toObject(entry.tokensByModel);
+    for (const model of Object.keys(tokensByModel)) {
+      const normalized = model.trim();
+      if (!normalized.startsWith("claude-") || seen.has(normalized)) continue;
+      seen.add(normalized);
+      ordered.push(normalized);
+    }
+  }
+
+  return ordered;
+}
+
+export async function buildClaudeRuntimeModelCatalog(): Promise<RuntimeAgentModelCatalog | null> {
+  const settings = await readJsonFileIfPresent<ClaudeSettings>(join(homedir(), ".claude", "settings.json"));
+  const stats = await readJsonFileIfPresent<ClaudeStatsCache>(join(homedir(), ".claude", "stats-cache.json"));
+  const reasoningOptions = await detectReasoningOptionsFromHelp(["claude", "claude-code", "cc"]);
+  const discoveredModels = collectClaudeStatsModels(stats);
+  const configuredModel = typeof settings?.model === "string" ? settings.model.trim().toLowerCase() : null;
+
+  const availableModels = uniqueModelOptions(discoveredModels.map((model) => {
+    return toRuntimeModelOption(
+      model,
+      `Model discovered from the local Claude Code installation (${model}).`,
+      getClaudeAccessForModel(model),
+      formatClaudeModelLabel,
+    );
+  }));
+
+  if (availableModels.length === 0 && !configuredModel) {
+    return null;
+  }
+
+  const allModels = availableModels.length > 0
+    ? availableModels
+    : [
+        toRuntimeModelOption(
+          configuredModel ?? "sonnet",
+          "Model configured in the local Claude Code settings.",
+          getClaudeAccessForModel(configuredModel ?? "sonnet"),
+          formatClaudeModelLabel,
+        ),
+      ];
+
+  const proModels = allModels.filter((model) => model.access.includes("pro"));
+  const maxModels = allModels.filter((model) => model.access.includes("max"));
+  const apiModels = allModels.filter((model) => model.access.includes("api"));
+  const modelContextById: Record<string, RuntimeAgentModelContext> = {};
+
+  for (const model of allModels) {
+    const usage = stats?.modelUsage?.[model.id];
+    const context = buildRuntimeModelContext({
+      maxTokens: usage?.contextWindow,
+      outputMaxTokens: usage?.maxOutputTokens,
+      source: "claude_stats_cache",
+      note: "Read from Claude Code's local stats cache.",
+    });
+    if (context) {
+      modelContextById[model.id] = context;
+    }
+  }
+
+  const defaultModelByAccess: Partial<Record<AgentModelAccess, string>> = {};
+  const proDefault = resolveClaudeConfiguredModel(configuredModel, proModels, "sonnet") ?? proModels[0]?.id ?? null;
+  const maxDefault = resolveClaudeConfiguredModel(configuredModel, maxModels, "opus")
+    ?? maxModels.find((model) => model.id.toLowerCase().includes("claude-opus"))?.id
+    ?? maxModels[0]?.id
+    ?? null;
+  const apiDefault = resolveClaudeConfiguredModel(configuredModel, apiModels, "sonnet") ?? apiModels[0]?.id ?? null;
+
+  if (proDefault) defaultModelByAccess.pro = proDefault;
+  if (maxDefault) defaultModelByAccess.max = maxDefault;
+  if (apiDefault) defaultModelByAccess.api = apiDefault;
+
+  const defaultReasoning = settings?.alwaysThinkingEnabled === true ? "high" : "medium";
+  const defaultReasoningByAccess: Partial<Record<AgentModelAccess, string>> = {};
+  for (const access of ["pro", "max", "api"] as const) {
+    const resolvedDefault = pickRuntimeDefaultReasoning(reasoningOptions, defaultReasoning, defaultReasoning);
+    if (resolvedDefault) {
+      defaultReasoningByAccess[access] = resolvedDefault;
+    }
+  }
+
+  return {
+    agent: "claude-code",
+    customModelPlaceholder: configuredModel || allModels[0]?.id || "",
+    defaultModelByAccess,
+    defaultReasoningByAccess,
+    modelsByAccess: {
+      ...(proModels.length > 0 ? { pro: proModels } : {}),
+      ...(maxModels.length > 0 ? { max: maxModels } : {}),
+      ...(apiModels.length > 0 ? { api: apiModels } : {}),
+    },
+    ...(Object.keys(modelContextById).length > 0 ? { modelContextById } : {}),
+    ...(reasoningOptions.length > 0
+      ? {
+          reasoningOptionsByAccess: {
+            pro: reasoningOptions,
+            max: reasoningOptions,
+            api: reasoningOptions,
+          },
+        }
+      : {}),
+  };
+}

package/web/.next/standalone/packages/web/src/lib/runtimeAgentModels/codex.ts

@@ -0,0 +1,211 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type {
+  AgentModelAccess,
+  AgentModelOption,
+  AgentReasoningOption,
+} from "@conductor-oss/core/types";
+import type {
+  RuntimeAgentModelContext,
+  RuntimeAgentModelCatalog,
+} from "../runtimeAgentModelsShared";
+import type { CodexCacheModel, CodexCacheReasoningLevel } from "./types";
+import {
+  buildRuntimeModelContext,
+  pickRuntimeDefaultModel,
+  pickRuntimeDefaultReasoning,
+  readTextFileIfPresent,
+  toReasoningOption,
+  uniqueModelOptions,
+} from "./helpers";
+
+function formatCodexModelLabel(raw: string): string {
+  return raw
+    .trim()
+    .split("-")
+    .filter(Boolean)
+    .map((part, index) => {
+      const lower = part.toLowerCase();
+      if (lower === "gpt") return "GPT";
+      if (lower === "codex") return "Codex";
+      if (lower === "spark") return "Spark";
+      if (lower === "mini") return "Mini";
+      if (lower === "max") return "Max";
+      if (index === 0) return part.toUpperCase();
+      return part[0]?.toUpperCase() + part.slice(1);
+    })
+    .join("-");
+}
+
+function toCodexModelOption(entry: CodexCacheModel): AgentModelOption | null {
+  if (typeof entry.slug !== "string" || entry.slug.trim().length === 0) {
+    return null;
+  }
+
+  const slug = entry.slug.trim();
+  const rawLabel = typeof entry.display_name === "string" && entry.display_name.trim().length > 0
+    ? entry.display_name.trim()
+    : slug;
+
+  return {
+    id: slug,
+    label: formatCodexModelLabel(rawLabel),
+    description: typeof entry.description === "string" && entry.description.trim().length > 0
+      ? entry.description.trim()
+      : `Model exposed by the local Codex installation (${slug}).`,
+    access: entry.supported_in_api === false ? ["chatgpt"] : ["chatgpt", "api"],
+  };
+}
+
+function parseCodexReasoningOptions(entry: CodexCacheModel): AgentReasoningOption[] {
+  const rawLevels = Array.isArray(entry.supported_reasoning_levels)
+    ? entry.supported_reasoning_levels as CodexCacheReasoningLevel[]
+    : [];
+
+  return rawLevels
+    .map((level) => {
+      if (typeof level.effort !== "string" || level.effort.trim().length === 0) {
+        return null;
+      }
+      return toReasoningOption(
+        level.effort,
+        typeof level.description === "string" ? level.description : null,
+      );
+    })
+    .filter((option): option is AgentReasoningOption => Boolean(option));
+}
+
+async function readCodexConfiguredState(): Promise<{ model: string | null; reasoningEffort: string | null }> {
+  const contents = await readTextFileIfPresent(join(homedir(), ".codex", "config.toml"));
+  if (!contents) {
+    return { model: null, reasoningEffort: null };
+  }
+
+  const modelMatch = contents.match(/^\s*model\s*=\s*"([^"]+)"\s*$/m);
+  const reasoningMatch = contents.match(/^\s*model_reasoning_effort\s*=\s*"([^"]+)"\s*$/m);
+
+  return {
+    model: modelMatch?.[1]?.trim() || null,
+    reasoningEffort: reasoningMatch?.[1]?.trim().toLowerCase() || null,
+  };
+}
+
+export function parseCodexRuntimeModelCatalog(
+  value: unknown,
+  configuredModel: string | null = null,
+  configuredReasoningEffort: string | null = null,
+): RuntimeAgentModelCatalog | null {
+  if (!value || typeof value !== "object") return null;
+
+  const models = Array.isArray((value as { models?: unknown }).models)
+    ? (value as { models: CodexCacheModel[] }).models
+    : [];
+
+  const listedModels = models
+    .map((entry, index) => ({ entry, index }))
+    .filter(({ entry }) => entry.visibility === "list")
+    .sort((left, right) => {
+      const leftPriority = typeof left.entry.priority === "number" ? left.entry.priority : Number.MAX_SAFE_INTEGER;
+      const rightPriority = typeof right.entry.priority === "number" ? right.entry.priority : Number.MAX_SAFE_INTEGER;
+      if (leftPriority !== rightPriority) return leftPriority - rightPriority;
+      return left.index - right.index;
+    })
+    .map(({ entry }) => ({ option: toCodexModelOption(entry), entry }))
+    .filter((entry): entry is { option: AgentModelOption; entry: CodexCacheModel } => Boolean(entry.option));
+
+  if (listedModels.length === 0) return null;
+
+  const reasoningOptionsByModel: Record<string, AgentReasoningOption[]> = {};
+  const defaultReasoningByModel: Record<string, string> = {};
+  const modelContextById: Record<string, RuntimeAgentModelContext> = {};
+
+  for (const { option, entry } of listedModels) {
+    const context = buildRuntimeModelContext({
+      maxTokens: entry.context_window ?? entry.max_context_window,
+      inputMaxTokens: entry.max_input_tokens,
+      outputMaxTokens: entry.max_output_tokens,
+      source: "codex_models_cache",
+      note: "Read from the local Codex models cache.",
+    });
+    if (context) {
+      modelContextById[option.id] = context;
+    }
+
+    const reasoningOptions = parseCodexReasoningOptions(entry);
+    if (reasoningOptions.length > 0) {
+      reasoningOptionsByModel[option.id] = reasoningOptions;
+      const defaultReasoning = typeof entry.default_reasoning_level === "string"
+        ? entry.default_reasoning_level.trim().toLowerCase()
+        : null;
+      const resolvedDefaultReasoning = pickRuntimeDefaultReasoning(
+        reasoningOptions,
+        configuredReasoningEffort,
+        defaultReasoning,
+      );
+      if (resolvedDefaultReasoning) {
+        defaultReasoningByModel[option.id] = resolvedDefaultReasoning;
+      }
+    }
+  }
+
+  const chatgptModels = listedModels.map(({ option }) => option);
+  const apiModels = listedModels
+    .map(({ option }) => option)
+    .filter((model) => model.access.includes("api"));
+
+  const fallbackPlaceholder = configuredModel?.trim() || chatgptModels[0]?.id || "";
+  const chatgptDefault = pickRuntimeDefaultModel(chatgptModels, configuredModel);
+  const apiDefault = pickRuntimeDefaultModel(apiModels, configuredModel);
+
+  const defaultReasoningByAccess: Partial<Record<AgentModelAccess, string>> = {};
+  if (chatgptDefault) {
+    const chatgptReasoning = pickRuntimeDefaultReasoning(
+      reasoningOptionsByModel[chatgptDefault] ?? [],
+      configuredReasoningEffort,
+      defaultReasoningByModel[chatgptDefault] ?? null,
+    );
+    if (chatgptReasoning) defaultReasoningByAccess.chatgpt = chatgptReasoning;
+  }
+  if (apiDefault) {
+    const apiReasoning = pickRuntimeDefaultReasoning(
+      reasoningOptionsByModel[apiDefault] ?? [],
+      configuredReasoningEffort,
+      defaultReasoningByModel[apiDefault] ?? null,
+    );
+    if (apiReasoning) defaultReasoningByAccess.api = apiReasoning;
+  }
+
+  return {
+    agent: "codex",
+    customModelPlaceholder: fallbackPlaceholder,
+    defaultModelByAccess: {
+      ...(chatgptDefault ? { chatgpt: chatgptDefault } : {}),
+      ...(apiDefault ? { api: apiDefault } : {}),
+    },
+    defaultReasoningByAccess,
+    modelsByAccess: {
+      chatgpt: chatgptModels,
+      api: apiModels,
+    },
+    ...(Object.keys(modelContextById).length > 0 ? { modelContextById } : {}),
+    defaultReasoningByModel,
+    reasoningOptionsByModel,
+  };
+}
+
+export async function buildCodexRuntimeModelCatalog(): Promise<RuntimeAgentModelCatalog | null> {
+  const contents = await readTextFileIfPresent(join(homedir(), ".codex", "models_cache.json"));
+  if (!contents) return null;
+
+  try {
+    const parsed = JSON.parse(contents) as unknown;
+    const configuredState = await readCodexConfiguredState();
+    return parseCodexRuntimeModelCatalog(
+      parsed,
+      configuredState.model,
+      configuredState.reasoningEffort,
+    );
+  } catch {
+    return null;
+  }
+}