routstrd 0.1.0

package/src/integrations/openclaw.ts

@@ -0,0 +1,177 @@
+import { randomBytes } from "crypto";
+import { existsSync, mkdirSync } from "fs";
+import { readFile, writeFile } from "fs/promises";
+import { dirname, join } from "path";
+import type { RoutstrdConfig } from "../utils/config";
+import { logger } from "../utils/logger";
+import type { SdkStore } from "@routstr/sdk";
+
+const OPENCLAW_CONFIG_PATH = join(process.env.HOME || "", ".openclaw/openclaw.json");
+const OPENCLAW_PROVIDER_ID = "routstr";
+const OPENCLAW_API_BASE = "http://localhost:8008/v1";
+const OPENCLAW_DEFAULT_PRIMARY_MODEL = "routstr/minimax-m2.5";
+const OPENCLAW_DEFAULT_FALLBACK_MODEL = "routstr/kimi-k2.5";
+const OPENCLAW_CLIENT_ID = "openclaw";
+const OPENCLAW_NAME = "OpenClaw";
+
+type RoutstrModel = {
+  id: string;
+  name?: string;
+};
+
+type OpenClawModelEntry = {
+  id: string;
+  name: string;
+  reasoning: boolean;
+};
+
+type OpenClawConfig = {
+  models?: {
+    providers?: Record<string, {
+      baseUrl?: string;
+      apiKey?: string;
+      api?: string;
+      models?: OpenClawModelEntry[];
+    }>;
+  };
+  agents?: {
+    defaults?: {
+      model?: {
+        primary?: string;
+        fallbacks?: string[];
+      };
+      models?: Record<string, {
+        alias?: string;
+      }>;
+    };
+  };
+};
+
+function toAlias(modelId: string): string {
+  if (modelId === "claude-sonnet-4.5") return "sonnet-4.5";
+  if (modelId === "claude-opus-4.5") return "opus-4.5";
+  if (modelId === "gemini-3-pro-preview") return "gemini-3-pro";
+  if (modelId === "gemini-3-flash-preview") return "gemini-3-flash";
+  if (modelId === "kimi-k2-thinking") return "kimi-k2";
+  if (modelId === "deepseek-v3.2-speciale") return "deepseek-special";
+  if (modelId === "grok-code-fast-1") return "grok-code";
+  return modelId;
+}
+
+function generateApiKey(): string {
+  const bytes = randomBytes(24);
+  return `sk-${bytes.toString("hex")}`;
+}
+
+export async function installOpenClawIntegration(
+  config: RoutstrdConfig,
+  store: SdkStore,
+): Promise<void> {
+  logger.log("\nInstalling routstr models in openclaw.json...");
+
+  const port = config.port || 8008;
+
+  // Get or create clientId entry for OpenClaw
+  const state = store.getState();
+  const existingClient = (state.clientIds || []).find(
+    (c: { clientId: string }) => c.clientId === OPENCLAW_CLIENT_ID,
+  );
+
+  let apiKey: string;
+  if (existingClient) {
+    apiKey = existingClient.apiKey;
+    logger.log(`Using existing API key for ${OPENCLAW_NAME}`);
+  } else {
+    apiKey = generateApiKey();
+    // Add new clientId entry using proper store action
+    store.getState().setClientIds((prev) => [
+      ...(prev || []),
+      {
+        clientId: OPENCLAW_CLIENT_ID,
+        name: OPENCLAW_NAME,
+        apiKey,
+        createdAt: Date.now(),
+      },
+    ]);
+    logger.log(`Created new API key for ${OPENCLAW_NAME}`);
+  }
+
+  let openclawConfig: OpenClawConfig = {};
+
+  try {
+    if (existsSync(OPENCLAW_CONFIG_PATH)) {
+      const content = await readFile(OPENCLAW_CONFIG_PATH, "utf-8");
+      openclawConfig = JSON.parse(content) as OpenClawConfig;
+    }
+  } catch {
+    openclawConfig = {};
+  }
+
+  if (!openclawConfig.models) {
+    openclawConfig.models = {};
+  }
+  if (!openclawConfig.models.providers) {
+    openclawConfig.models.providers = {};
+  }
+  if (!openclawConfig.agents) {
+    openclawConfig.agents = {};
+  }
+  if (!openclawConfig.agents.defaults) {
+    openclawConfig.agents.defaults = {};
+  }
+
+  try {
+    mkdirSync(dirname(OPENCLAW_CONFIG_PATH), { recursive: true });
+
+    const response = await fetch(`http://localhost:${port}/models`);
+    const data = await response.json() as { output?: { models: RoutstrModel[] } };
+    const models = data.output?.models || [];
+
+    if (models.length === 0) {
+      logger.log("No models found from routstr daemon.");
+      return;
+    }
+
+    const providerModels: OpenClawModelEntry[] = models.map((model) => ({
+      id: model.id,
+      name: model.name || model.id,
+      reasoning: true,
+    }));
+
+    openclawConfig.models.providers[OPENCLAW_PROVIDER_ID] = {
+      baseUrl: OPENCLAW_API_BASE,
+      apiKey,
+      api: "openai-completions",
+      models: providerModels,
+    };
+
+    const availableModelIds = new Set(providerModels.map((model) => model.id));
+    const primaryId = availableModelIds.has("gpt-5.3-codex") ? "gpt-5.3-codex" : providerModels[0]?.id;
+    const fallbackId = availableModelIds.has("minimax-m2.5")
+      ? "minimax-m2.5"
+      : providerModels.find((model) => model.id !== primaryId)?.id;
+
+    if (primaryId) {
+      openclawConfig.agents.defaults.model = {
+        primary: `${OPENCLAW_PROVIDER_ID}/${primaryId}`,
+        fallbacks: fallbackId ? [`${OPENCLAW_PROVIDER_ID}/${fallbackId}`] : [],
+      };
+    } else {
+      openclawConfig.agents.defaults.model = {
+        primary: OPENCLAW_DEFAULT_PRIMARY_MODEL,
+        fallbacks: [OPENCLAW_DEFAULT_FALLBACK_MODEL],
+      };
+    }
+
+    // const aliasMap: Record<string, { alias?: string }> = {};
+    // for (const model of providerModels) {
+    //   aliasMap[`${OPENCLAW_PROVIDER_ID}/${model.id}`] = { alias: toAlias(model.id) };
+    // }
+    // openclawConfig.agents.defaults.models = aliasMap;
+
+    await writeFile(OPENCLAW_CONFIG_PATH, JSON.stringify(openclawConfig, null, 2));
+    logger.log(`Added "${OPENCLAW_PROVIDER_ID}" provider with ${models.length} models to openclaw.json`);
+  } catch (error) {
+    logger.error("Failed to install models in openclaw.json:", error);
+  }
+}

package/src/integrations/opencode.ts

@@ -0,0 +1,120 @@
+import { randomBytes } from "crypto";
+import { existsSync, mkdirSync } from "fs";
+import { readFile, writeFile } from "fs/promises";
+import { dirname, join } from "path";
+import type { RoutstrdConfig } from "../utils/config";
+import { logger } from "../utils/logger";
+import type { SdkStore } from "@routstr/sdk";
+
+const OPENCODE_CONFIG_PATH = join(process.env.HOME || "", ".config/opencode/opencode.json");
+const OPENCODE_SMALL_MODEL = "routstr/minimax-m2.5";
+const OPENCODE_CLIENT_ID = "opencode";
+const OPENCODE_NAME = "OpenCode";
+
+type RoutstrModel = {
+  id: string;
+  name?: string;
+};
+
+function generateApiKey(): string {
+  const bytes = randomBytes(24);
+  return `sk-${bytes.toString("hex")}`;
+}
+
+export async function installOpencodeIntegration(
+  config: RoutstrdConfig,
+  store: SdkStore,
+): Promise<void> {
+  logger.log("\nInstalling routstr models in opencode.json...");
+
+  const port = config.port || 8008;
+
+  // Get or create clientId entry for OpenCode
+  const state = store.getState();
+  const existingClient = (state.clientIds || []).find(
+    (c: { clientId: string }) => c.clientId === OPENCODE_CLIENT_ID,
+  );
+
+  let apiKey: string;
+  if (existingClient) {
+    apiKey = existingClient.apiKey;
+    logger.log(`Using existing API key for ${OPENCODE_NAME}`);
+  } else {
+    apiKey = generateApiKey();
+    // Add new clientId entry using proper store action
+    store.getState().setClientIds((prev) => [
+      ...(prev || []),
+      {
+        clientId: OPENCODE_CLIENT_ID,
+        name: OPENCODE_NAME,
+        apiKey,
+        createdAt: Date.now(),
+      },
+    ]);
+    logger.log(`Created new API key for ${OPENCODE_NAME}`);
+  }
+
+  let opencodeConfig: {
+    provider?: Record<string, {
+      npm?: string;
+      name?: string;
+      options?: {
+        baseURL?: string;
+        apiKey?: string;
+        includeUsage?: boolean;
+      };
+      models?: Record<string, { name: string }>;
+    }>;
+    small_model?: string;
+  };
+
+  try {
+    if (existsSync(OPENCODE_CONFIG_PATH)) {
+      const content = await readFile(OPENCODE_CONFIG_PATH, "utf-8");
+      opencodeConfig = JSON.parse(content);
+    } else {
+      opencodeConfig = { provider: {} };
+    }
+  } catch {
+    opencodeConfig = { provider: {} };
+  }
+
+  if (!opencodeConfig.provider) {
+    opencodeConfig.provider = {};
+  }
+
+  try {
+    mkdirSync(dirname(OPENCODE_CONFIG_PATH), { recursive: true });
+
+    const response = await fetch(`http://localhost:${port}/models`);
+    const data = await response.json() as { output?: { models: RoutstrModel[] } };
+    const models = data.output?.models || [];
+
+    if (models.length === 0) {
+      logger.log("No models found from routstr daemon.");
+      return;
+    }
+
+    const modelsObj: Record<string, { name: string }> = {};
+    for (const model of models) {
+      modelsObj[model.id] = { name: model.name || model.id };
+    }
+
+    opencodeConfig.provider["routstr"] = {
+      npm: "@ai-sdk/openai-compatible",
+      name: "routstr",
+      options: {
+        baseURL: `http://localhost:${port}/`,
+        apiKey,
+        includeUsage: true,
+      },
+      models: modelsObj,
+    };
+    opencodeConfig.small_model = OPENCODE_SMALL_MODEL;
+
+    await writeFile(OPENCODE_CONFIG_PATH, JSON.stringify(opencodeConfig, null, 2));
+    logger.log(`Added "routstr" provider with ${models.length} models to opencode.json`);
+  } catch (error) {
+    logger.error("Failed to install models in opencode.json:", error);
+  }
+}

package/src/integrations/pi.ts

@@ -0,0 +1,116 @@
+import { randomBytes } from "crypto";
+import { existsSync, mkdirSync } from "fs";
+import { readFile, writeFile } from "fs/promises";
+import { dirname, join } from "path";
+import type { RoutstrdConfig } from "../utils/config";
+import { logger } from "../utils/logger";
+import type { SdkStore } from "@routstr/sdk";
+
+const PI_CONFIG_PATH = join(process.env.HOME || "", ".pi/agent/models.json");
+const PI_CLIENT_ID = "pi-agent";
+const PI_NAME = "Pi Agent";
+
+type RoutstrModel = {
+  id: string;
+  name?: string;
+};
+
+type PiModelEntry = {
+  id: string;
+};
+
+type PiProviderConfig = {
+  baseUrl?: string;
+  api?: string;
+  apiKey?: string;
+  models?: PiModelEntry[];
+};
+
+type PiConfig = {
+  providers?: Record<string, PiProviderConfig>;
+};
+
+function generateApiKey(): string {
+  const bytes = randomBytes(24);
+  return `sk-${bytes.toString("hex")}`;
+}
+
+export async function installPiIntegration(
+  config: RoutstrdConfig,
+  store: SdkStore,
+): Promise<void> {
+  logger.log("\nInstalling routstr models in pi models.json...");
+
+  const port = config.port || 8008;
+  const baseUrl = `http://localhost:${port}/v1`;
+
+  // Get or create clientId entry for Pi Agent
+  const state = store.getState();
+  const existingClient = (state.clientIds || []).find(
+    (c: { clientId: string }) => c.clientId === PI_CLIENT_ID,
+  );
+
+  let apiKey: string;
+  if (existingClient) {
+    apiKey = existingClient.apiKey;
+    logger.log(`Using existing API key for ${PI_NAME}`);
+  } else {
+    apiKey = generateApiKey();
+    // Add new clientId entry using proper store action
+    store.getState().setClientIds((prev) => [
+      ...(prev || []),
+      {
+        clientId: PI_CLIENT_ID,
+        name: PI_NAME,
+        apiKey,
+        createdAt: Date.now(),
+      },
+    ]);
+    logger.log(`Created new API key for ${PI_NAME}`);
+  }
+
+  let piConfig: PiConfig = {};
+
+  try {
+    if (existsSync(PI_CONFIG_PATH)) {
+      const content = await readFile(PI_CONFIG_PATH, "utf-8");
+      piConfig = JSON.parse(content) as PiConfig;
+    }
+  } catch {
+    piConfig = {};
+  }
+
+  if (!piConfig.providers) {
+    piConfig.providers = {};
+  }
+
+  try {
+    // Ensure directory exists
+    mkdirSync(dirname(PI_CONFIG_PATH), { recursive: true });
+
+    const response = await fetch(`http://localhost:${port}/models`);
+    const data = await response.json() as { output?: { models: RoutstrModel[] } };
+    const models = data.output?.models || [];
+
+    if (models.length === 0) {
+      logger.log("No models found from routstr daemon.");
+      return;
+    }
+
+    const providerModels: PiModelEntry[] = models.map((model) => ({
+      id: model.id,
+    }));
+
+    piConfig.providers["routstr"] = {
+      baseUrl,
+      api: "openai-completions",
+      apiKey,
+      models: providerModels,
+    };
+
+    await writeFile(PI_CONFIG_PATH, JSON.stringify(piConfig, null, 2));
+    logger.log(`Added "routstr" provider with ${models.length} models to pi models.json`);
+  } catch (error) {
+    logger.error("Failed to install models in pi models.json:", error);
+  }
+}

package/src/start-daemon.ts

@@ -0,0 +1,90 @@
+import { LOG_FILE } from "./utils/config";
+import { logger } from "./utils/logger";
+import { existsSync, mkdirSync } from "fs";
+import { dirname, join } from "path";
+
+export async function startDaemon(
+  options: { port?: string; provider?: string } = {},
+): Promise<void> {
+  const args: string[] = [];
+  const port = options.port || "8008";
+  const pollIntervalMs = 250;
+  const startupTimeoutMs = 10 * 60 * 1000;
+
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 2000);
+    const existing = await fetch(`http://localhost:${port}/health`, {
+      signal: controller.signal,
+    });
+    clearTimeout(timeoutId);
+    if (existing.ok) {
+      logger.log(`Routstr daemon already running on http://localhost:${port}`);
+      return;
+    }
+  } catch {
+    // Daemon is not running yet; continue with startup.
+  }
+
+  if (options.port) {
+    args.push("--port", options.port);
+  }
+  if (options.provider) {
+    args.push("--provider", options.provider);
+  }
+
+  // Ensure log directory exists
+  const logDir = dirname(LOG_FILE);
+  if (!existsSync(logDir)) {
+    mkdirSync(logDir, { recursive: true });
+  }
+
+  // Use shell redirection to append stdout/stderr to log file
+  // Bun.file() overwrites, so we need shell >> for appending
+  const daemonScript = `${import.meta.dir}/daemon/index.ts`;
+  const shellCmd = `bun run "${daemonScript}" ${args.map(a => `'${a}'`).join(" ")} >> "${LOG_FILE}" 2>&1`;
+
+  const proc = Bun.spawn(["sh", "-c", shellCmd], {
+    stdout: "inherit",
+    stderr: "inherit",
+    stdin: "ignore",
+    detached: true,
+  });
+
+  proc.unref();
+
+  let exitCode: number | null = null;
+  proc.exited.then((code) => {
+    exitCode = code;
+  });
+
+  const maxPolls = Math.ceil(startupTimeoutMs / pollIntervalMs);
+  for (let i = 0; i < maxPolls; i++) {
+    await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+
+    if (exitCode !== null) {
+      throw new Error(
+        `Daemon process exited early with code ${exitCode}. Check logs at ${LOG_FILE}`,
+      );
+    }
+
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 2000);
+      const res = await fetch(`http://localhost:${port}/health`, {
+        signal: controller.signal,
+      });
+      clearTimeout(timeoutId);
+      if (res.ok) {
+        logger.log(`Routstr daemon started (PID: ${proc.pid}).`);
+        return;
+      }
+    } catch {
+      // Not ready yet
+    }
+  }
+
+  throw new Error(
+    `Daemon failed to start within ${Math.round(startupTimeoutMs / 1000)} seconds. Check logs at ${LOG_FILE}`,
+  );
+}