@bryceli/openclaw 0.1.0

package/README.md

@@ -0,0 +1,45 @@
+# OpenClaw
+
+This project installs `openclaw` locally with npm and keeps all OpenClaw state inside this project.
+
+## What is isolated
+
+- OpenClaw is installed in local `node_modules`
+- config is stored in `.openclaw-home/openclaw.json`
+- secrets are stored in `.openclaw-home/.env`
+- workspace is stored in `.openclaw-home/workspace`
+
+## Package name
+
+This publishable wrapper package is intended to be published as `@bryceli/openclaw`.
+
+## Quick start
+
+```bash
+npm install
+npm run setup
+npm run gateway
+```
+
+## Useful commands
+
+```bash
+npm run openclaw -- --version
+npm run dashboard
+npm run models:list
+```
+
+## Interface types
+
+- OpenAI Compatible (最常用)
+- Anthropic Native (原生)
+- OpenAI Responses (新接口)
+- Google Gemini (原生)
+- Ollama Native (本地原生)
+
+## Notes
+
+- This project is only for OpenClaw.
+- It does not configure Claude Code.
+- It does not configure OpenCode.
+- All paths are project-local through `OPENCLAW_HOME`.

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@bryceli/openclaw",
+  "version": "0.1.0",
+  "description": "Project-local OpenClaw installer and model configurator.",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "setup": "node scripts/setup-openclaw.mjs",
+    "openclaw": "node scripts/run-openclaw.mjs",
+    "gateway": "node scripts/run-openclaw.mjs gateway run",
+    "dashboard": "node scripts/run-openclaw.mjs dashboard",
+    "models:list": "node scripts/run-openclaw.mjs models list",
+    "models:test": "node scripts/run-openclaw.mjs models test"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.10.1",
+    "openclaw": "latest",
+    "picocolors": "^1.1.1"
+  }
+}

package/scripts/run-openclaw.mjs

@@ -0,0 +1,29 @@
+import { spawn } from "node:child_process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const projectRoot = path.resolve(__dirname, "..");
+const openclawHome = path.join(projectRoot, ".openclaw-home");
+
+const npmCommand = process.platform === "win32" ? "npm.cmd" : "npm";
+const args = ["exec", "--", "openclaw", ...process.argv.slice(2)];
+
+const child = spawn(npmCommand, args, {
+  cwd: projectRoot,
+  env: {
+    ...process.env,
+    OPENCLAW_HOME: openclawHome
+  },
+  stdio: "inherit"
+});
+
+child.on("exit", (code, signal) => {
+  if (signal) {
+    process.kill(process.pid, signal);
+    return;
+  }
+
+  process.exit(code ?? 0);
+});

package/scripts/setup-openclaw.mjs

@@ -0,0 +1,393 @@
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import { mkdirSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const projectRoot = path.resolve(__dirname, "..");
+const openclawHome = path.join(projectRoot, ".openclaw-home");
+const workspaceDir = path.join(openclawHome, "workspace");
+const configPath = path.join(openclawHome, "openclaw.json");
+const envPath = path.join(openclawHome, ".env");
+
+const INTERFACE_TYPES = [
+  {
+    value: "openai-compatible",
+    label: "OpenAI Compatible (最常用)",
+    hint: "For proxy gateways and generic OpenAI-style APIs",
+    defaultBaseUrl: "https://api.openai.com/v1"
+  },
+  {
+    value: "anthropic-native",
+    label: "Anthropic Native (原生)",
+    hint: "For Anthropic-compatible Messages endpoints",
+    defaultBaseUrl: "https://api.anthropic.com"
+  },
+  {
+    value: "openai-responses",
+    label: "OpenAI Responses (新接口)",
+    hint: "For OpenAI Responses-style providers",
+    defaultBaseUrl: "https://api.openai.com/v1"
+  },
+  {
+    value: "google-gemini",
+    label: "Google Gemini (原生)",
+    hint: "For Gemini-native APIs",
+    defaultBaseUrl: "https://generativelanguage.googleapis.com"
+  },
+  {
+    value: "ollama-native",
+    label: "Ollama Native (本地原生)",
+    hint: "For Ollama native API without /v1",
+    defaultBaseUrl: "http://127.0.0.1:11434"
+  }
+];
+
+await main();
+
+async function main() {
+  console.clear();
+  p.intro(pc.bgBlue(pc.white(" OpenClaw Local Setup (安装器) ")));
+
+  const interfaceType = await p.select({
+    message: "Select the API interface type (选择接口类型)",
+    options: INTERFACE_TYPES.map((item) => ({
+      value: item.value,
+      label: item.label,
+      hint: item.hint
+    })),
+    initialValue: "openai-compatible"
+  });
+
+  if (p.isCancel(interfaceType)) {
+    exitCancelled();
+  }
+
+  const interfaceConfig = INTERFACE_TYPES.find((item) => item.value === interfaceType);
+  if (!interfaceConfig) {
+    throw new Error(`Unsupported interface type: ${interfaceType}`);
+  }
+
+  const suggestedBaseUrl = await getSuggestedBaseUrl(interfaceConfig);
+  const baseUrl = await promptRequiredText({
+    message: "Enter the API base URL (接口地址)",
+    placeholder: suggestedBaseUrl,
+    initialValue: suggestedBaseUrl
+  });
+
+  const apiKeyDefault = interfaceType === "ollama-native" ? "ollama-local" : "";
+  const apiKey = await promptOptionalText({
+    message: "Enter the API key if needed (API Key 可按需留空)",
+    placeholder: apiKeyDefault || "sk-...",
+    initialValue: apiKeyDefault
+  });
+
+  const detectedPrimary = await tryDetectModelId(baseUrl, interfaceType);
+  const primaryModelId = await promptRequiredText({
+    message: "Enter the primary model ID (主模型 ID)",
+    placeholder: detectedPrimary || getSuggestedPrimaryModelId(interfaceType),
+    initialValue: detectedPrimary || getSuggestedPrimaryModelId(interfaceType)
+  });
+
+  const fallbackModelId = await promptOptionalText({
+    message: "Enter the fallback model ID if you want one (备用模型可留空)",
+    placeholder: primaryModelId,
+    initialValue: primaryModelId
+  });
+
+  const config = buildOpenClawConfig({
+    interfaceType,
+    baseUrl,
+    apiKey: apiKey || apiKeyDefault,
+    primaryModelId,
+    fallbackModelId: fallbackModelId || primaryModelId
+  });
+
+  mkdirSync(workspaceDir, { recursive: true });
+  writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+  writeFileSync(envPath, buildEnvFile(config.envEntries), "utf8");
+
+  const notes = [];
+  if (interfaceType === "openai-responses" && !isOfficialOpenAiBaseUrl(baseUrl)) {
+    notes.push("Custom Responses endpoints are written using OpenClaw's practical openai-completions compatibility mode.");
+  }
+  if (interfaceType === "ollama-native") {
+    notes.push("Ollama uses native API mode with no /v1 suffix so tool calling stays reliable.");
+  }
+
+  let outro = `${pc.green("OpenClaw project setup complete")}\n\n`;
+  outro += `${pc.cyan("Project")}: ${projectRoot}\n`;
+  outro += `${pc.cyan("OPENCLAW_HOME")}: ${openclawHome}\n`;
+  outro += `${pc.cyan("Config")}: ${configPath}\n`;
+  outro += `${pc.cyan("Env")}: ${envPath}\n`;
+  outro += `${pc.cyan("Primary model")}: ${config.primaryModelRef}\n`;
+  outro += `${pc.cyan("Fallback model")}: ${config.fallbackModelRef}\n`;
+
+  if (notes.length) {
+    outro += `\n${pc.yellow("Notes")}:\n- ${notes.join("\n- ")}`;
+  }
+
+  p.outro(outro);
+}
+
+async function getSuggestedBaseUrl(interfaceConfig) {
+  if (interfaceConfig.value === "ollama-native") {
+    return "http://127.0.0.1:11434";
+  }
+
+  return interfaceConfig.defaultBaseUrl;
+}
+
+function buildOpenClawConfig({ interfaceType, baseUrl, apiKey, primaryModelId, fallbackModelId }) {
+  const providerId = getProviderId(interfaceType);
+  const envEntries = buildEnvEntries(interfaceType, apiKey);
+  const providerModelIds = new Set([primaryModelId, fallbackModelId].filter(Boolean));
+  const modelRefs = [...providerModelIds].map((id) => `${providerId}/${id}`);
+  const providerModels = [...providerModelIds].map((id) => ({
+    id,
+    name: id,
+    contextWindow: 131072,
+    maxTokens: 131072,
+    cost: {
+      input: 0,
+      output: 0,
+      cacheRead: 0,
+      cacheWrite: 0
+    }
+  }));
+
+  const config = {
+    agents: {
+      defaults: {
+        workspace: workspaceDir,
+        model: {
+          primary: `${providerId}/${primaryModelId}`,
+          fallbacks:
+            fallbackModelId && fallbackModelId !== primaryModelId
+              ? [`${providerId}/${fallbackModelId}`]
+              : []
+        },
+        models: Object.fromEntries(
+          modelRefs.map((ref, index) => [
+            ref,
+            { alias: index === 0 ? "Primary (主模型)" : "Fallback (备用模型)" }
+          ])
+        )
+      }
+    },
+    models: {
+      mode: "merge",
+      providers: {
+        [providerId]: buildProviderConfig({
+          providerId,
+          interfaceType,
+          baseUrl,
+          providerModels
+        })
+      }
+    }
+  };
+
+  return {
+    ...config,
+    envEntries,
+    primaryModelRef: `${providerId}/${primaryModelId}`,
+    fallbackModelRef:
+      fallbackModelId && fallbackModelId !== primaryModelId
+        ? `${providerId}/${fallbackModelId}`
+        : `${providerId}/${primaryModelId}`
+  };
+}
+
+function buildProviderConfig({ providerId, interfaceType, baseUrl, providerModels }) {
+  if (interfaceType === "google-gemini") {
+    return {
+      baseUrl,
+      apiKey: "${OPENCLAW_MODEL_API_KEY}",
+      models: providerModels
+    };
+  }
+
+  if (interfaceType === "ollama-native") {
+    return {
+      baseUrl: stripTrailingSlash(baseUrl),
+      apiKey: "${OLLAMA_API_KEY}",
+      api: "ollama",
+      models: providerModels
+    };
+  }
+
+  if (interfaceType === "anthropic-native") {
+    return {
+      baseUrl: stripTrailingSlash(baseUrl),
+      apiKey: "${OPENCLAW_MODEL_API_KEY}",
+      api: "anthropic-messages",
+      models: providerModels
+    };
+  }
+
+  return {
+    baseUrl: ensureV1BaseUrl(baseUrl),
+    apiKey: "${OPENCLAW_MODEL_API_KEY}",
+    api: "openai-completions",
+    models: providerModels
+  };
+}
+
+function buildEnvEntries(interfaceType, apiKey) {
+  if (interfaceType === "ollama-native") {
+    return {
+      OLLAMA_API_KEY: apiKey || "ollama-local"
+    };
+  }
+
+  if (interfaceType === "google-gemini") {
+    return {
+      OPENCLAW_MODEL_API_KEY: apiKey
+    };
+  }
+
+  return {
+    OPENCLAW_MODEL_API_KEY: apiKey
+  };
+}
+
+function buildEnvFile(entries) {
+  const lines = Object.entries(entries)
+    .filter(([, value]) => typeof value === "string" && value.length > 0)
+    .map(([key, value]) => `${key}=${escapeEnvValue(value)}`);
+
+  return `${lines.join("\n")}\n`;
+}
+
+function escapeEnvValue(value) {
+  return JSON.stringify(String(value));
+}
+
+function getProviderId(interfaceType) {
+  switch (interfaceType) {
+    case "anthropic-native":
+      return "customanthropic";
+    case "google-gemini":
+      return "google";
+    case "ollama-native":
+      return "ollama";
+    case "openai-responses":
+      return "customopenairesponses";
+    case "openai-compatible":
+    default:
+      return "customopenai";
+  }
+}
+
+function getSuggestedPrimaryModelId(interfaceType) {
+  switch (interfaceType) {
+    case "anthropic-native":
+      return "claude-sonnet-4-5";
+    case "google-gemini":
+      return "gemini-2.5-pro";
+    case "ollama-native":
+      return "llama3.2";
+    case "openai-responses":
+    case "openai-compatible":
+    default:
+      return "gpt-4.1";
+  }
+}
+
+async function tryDetectModelId(baseUrl, interfaceType) {
+  const urls = [];
+  const normalized = stripTrailingSlash(baseUrl);
+  if (!normalized) {
+    return null;
+  }
+
+  if (interfaceType === "ollama-native") {
+    urls.push(`${normalized}/api/tags`);
+  } else {
+    urls.push(`${ensureV1BaseUrl(normalized)}/models`);
+    urls.push(`${normalized}/api/tags`);
+  }
+
+  for (const url of urls) {
+    try {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 1500);
+      const response = await fetch(url, { signal: controller.signal });
+      clearTimeout(timeout);
+      if (!response.ok) {
+        continue;
+      }
+
+      const payload = await response.json();
+      const v1Id = payload?.data?.[0]?.id;
+      if (typeof v1Id === "string" && v1Id.trim()) {
+        return v1Id.trim();
+      }
+
+      const tagId = payload?.models?.[0]?.name ?? payload?.models?.[0]?.model;
+      if (typeof tagId === "string" && tagId.trim()) {
+        return tagId.trim();
+      }
+    } catch {
+      // Best-effort only.
+    }
+  }
+
+  return null;
+}
+
+function ensureV1BaseUrl(value) {
+  const normalized = stripTrailingSlash(value);
+  return normalized.endsWith("/v1") ? normalized : `${normalized}/v1`;
+}
+
+function stripTrailingSlash(value) {
+  return String(value ?? "").replace(/\/+$/, "");
+}
+
+function isOfficialOpenAiBaseUrl(value) {
+  return /https:\/\/api\.openai\.com\/?v1?$/i.test(stripTrailingSlash(value));
+}
+
+async function promptRequiredText({ message, placeholder, initialValue }) {
+  const answer = await p.text({
+    message,
+    placeholder,
+    initialValue,
+    validate: (value) => {
+      if (!value || !value.trim()) {
+        return "This field is required.";
+      }
+      return undefined;
+    }
+  });
+
+  if (p.isCancel(answer)) {
+    exitCancelled();
+  }
+
+  return answer.trim();
+}
+
+async function promptOptionalText({ message, placeholder, initialValue }) {
+  const answer = await p.text({
+    message,
+    placeholder,
+    initialValue,
+    validate: () => undefined
+  });
+
+  if (p.isCancel(answer)) {
+    exitCancelled();
+  }
+
+  return answer.trim();
+}
+
+function exitCancelled() {
+  p.cancel("Operation cancelled");
+  process.exit(0);
+}