@zhiman_innies/innies-codex 0.122.39 → 0.122.40

package/bin/innies-config.js

@@ -0,0 +1,573 @@
+import os from "node:os";
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const DEFAULT_MODEL = "qwen35_35b";
+const DEFAULT_PROVIDER = "zhiman_35b";
+const DASHSCOPE_MODEL = "qwen3.6-plus";
+const QWEN_MODELS = new Set([DEFAULT_MODEL, DASHSCOPE_MODEL]);
+const LEGACY_MODELS = new Set(["qwen-plus", "qwen-plus-latest"]);
+const DEFAULT_HOME_DIR = ".inniescoder";
+const DEFAULT_CATALOG_FILENAME = "catalog.json";
+const DEFAULT_CONFIG_FILENAME = "config.toml";
+const DEFAULT_STATE_FILENAME = "innies-state.json";
+const DEFAULT_SUPERPOWERS_DIRNAME = "superpowers";
+const INSTALL_SUPERPOWERS_ENV = "INNIES_INSTALL_SUPERPOWERS";
+const SUPERPOWERS_MARKER_FILENAME = ".innies-superpowers.marker";
+const ZHIMAN_35B_PROVIDER_HEADER = "[model_providers.zhiman_35b]";
+const ZHIMAN_35B_RESPONSES_BASE_URL = "http://101.237.37.116:7380/v1";
+const DASHSCOPE_PROVIDER_HEADER = "[model_providers.dashscope]";
+const DASHSCOPE_RESPONSES_BASE_URL =
+  "https://dashscope.aliyuncs.com/api/v2/apps/protocols/compatible-mode/v1";
+const RESERVED_PROVIDER_HEADERS = Object.freeze([
+  "[model_providers.openai]",
+  "[model_providers.ollama]",
+  "[model_providers.lmstudio]",
+]);
+const MODEL_SELECTION_STATES = Object.freeze({
+  MANAGED_DEFAULT: "managed_default",
+  USER_SELECTED: "user_selected",
+});
+const ROOT_MANAGED_SETTINGS = Object.freeze([
+  ["model_provider", null],
+  ["model", null],
+  ["model_catalog_json", null],
+  ["model_reasoning_effort", null],
+]);
+const LEGACY_MANAGED_GPT_MODEL = "gpt-5.5";
+const LEGACY_MANAGED_GPT_PROVIDER = "openai";
+const LEGACY_MANAGED_GPT_REASONING = "high";
+
+export function resolveInniesHome() {
+  if (process.env.INNIES_HOME) {
+    return process.env.INNIES_HOME;
+  }
+  return path.join(os.homedir(), DEFAULT_HOME_DIR);
+}
+
+export function ensureInniesHomeDefaults(homeDir) {
+  const state = loadInniesState(homeDir);
+  const catalogPath = path.join(homeDir, DEFAULT_CATALOG_FILENAME);
+  ensureInniesCatalog(catalogPath);
+  if (shouldInstallInniesSuperpowers()) {
+    ensureInniesSuperpowers(homeDir);
+  } else {
+    removeManagedInniesSuperpowers(homeDir);
+  }
+  const nextState = ensureInniesConfig(
+    path.join(homeDir, DEFAULT_CONFIG_FILENAME),
+    catalogPath,
+    state,
+  );
+  writeInniesState(homeDir, nextState);
+}
+
+function defaultCatalogAssetPath() {
+  return path.join(__dirname, "..", "assets", "innies-catalog.json");
+}
+
+function defaultSuperpowersAssetPath() {
+  return path.join(__dirname, "..", "assets", DEFAULT_SUPERPOWERS_DIRNAME);
+}
+
+function shouldInstallInniesSuperpowers() {
+  const value = process.env[INSTALL_SUPERPOWERS_ENV]?.trim().toLowerCase();
+  return value === "1" || value === "true" || value === "yes";
+}
+
+function loadDefaultCatalog() {
+  return JSON.parse(fs.readFileSync(defaultCatalogAssetPath(), "utf8"));
+}
+
+function writeJsonFile(filePath, value) {
+  fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+function ensureInniesSuperpowers(homeDir) {
+  const sourceDir = defaultSuperpowersAssetPath();
+  if (!fs.existsSync(sourceDir)) {
+    return;
+  }
+
+  const destDir = path.join(homeDir, DEFAULT_SUPERPOWERS_DIRNAME);
+  const markerPath = path.join(destDir, SUPERPOWERS_MARKER_FILENAME);
+  const fingerprint = directoryFingerprint(sourceDir);
+  if (
+    fs.existsSync(destDir) &&
+    readTextFile(markerPath)?.trim() === fingerprint
+  ) {
+    return;
+  }
+
+  if (fs.existsSync(markerPath)) {
+    fs.rmSync(destDir, { recursive: true, force: true });
+  }
+  copyDirectoryContents(sourceDir, destDir);
+  fs.writeFileSync(markerPath, `${fingerprint}\n`);
+}
+
+function removeManagedInniesSuperpowers(homeDir) {
+  const destDir = path.join(homeDir, DEFAULT_SUPERPOWERS_DIRNAME);
+  const markerPath = path.join(destDir, SUPERPOWERS_MARKER_FILENAME);
+  if (!fs.existsSync(markerPath)) {
+    return;
+  }
+
+  fs.rmSync(destDir, { recursive: true, force: true });
+}
+
+function readTextFile(filePath) {
+  try {
+    return fs.readFileSync(filePath, "utf8");
+  } catch {
+    return null;
+  }
+}
+
+function directoryFingerprint(rootDir) {
+  const hash = crypto.createHash("sha256");
+  for (const relativePath of listRelativeFiles(rootDir)) {
+    const sourcePath = path.join(rootDir, relativePath);
+    hash.update(relativePath.split(path.sep).join("/"));
+    hash.update("\0");
+    hash.update(fs.readFileSync(sourcePath));
+    hash.update("\0");
+  }
+  return hash.digest("hex");
+}
+
+function listRelativeFiles(rootDir, currentDir = rootDir) {
+  const entries = fs
+    .readdirSync(currentDir, { withFileTypes: true })
+    .sort((a, b) => a.name.localeCompare(b.name));
+  const files = [];
+
+  for (const entry of entries) {
+    const entryPath = path.join(currentDir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...listRelativeFiles(rootDir, entryPath));
+      continue;
+    }
+    if (entry.isFile()) {
+      files.push(path.relative(rootDir, entryPath));
+    }
+  }
+
+  return files;
+}
+
+function copyDirectoryContents(sourceDir, destDir) {
+  fs.mkdirSync(destDir, { recursive: true });
+  const entries = fs.readdirSync(sourceDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const sourcePath = path.join(sourceDir, entry.name);
+    const destPath = path.join(destDir, entry.name);
+    if (entry.isDirectory()) {
+      copyDirectoryContents(sourcePath, destPath);
+      continue;
+    }
+    if (entry.isFile()) {
+      fs.mkdirSync(path.dirname(destPath), { recursive: true });
+      fs.copyFileSync(sourcePath, destPath);
+      fs.chmodSync(destPath, fs.statSync(sourcePath).mode);
+    }
+  }
+}
+
+function stateFilePath(homeDir) {
+  return path.join(homeDir, DEFAULT_STATE_FILENAME);
+}
+
+function defaultInniesState() {
+  return {
+    model_selection_state: MODEL_SELECTION_STATES.MANAGED_DEFAULT,
+  };
+}
+
+function loadInniesState(homeDir) {
+  const filePath = stateFilePath(homeDir);
+  if (!fs.existsSync(filePath)) {
+    return defaultInniesState();
+  }
+
+  try {
+    const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+    if (
+      parsed &&
+      Object.values(MODEL_SELECTION_STATES).includes(parsed.model_selection_state)
+    ) {
+      return parsed;
+    }
+  } catch {}
+
+  return defaultInniesState();
+}
+
+function writeInniesState(homeDir, state) {
+  writeJsonFile(stateFilePath(homeDir), state);
+}
+
+function ensureInniesCatalog(catalogPath) {
+  const defaultCatalog = loadDefaultCatalog();
+  if (!fs.existsSync(catalogPath)) {
+    writeJsonFile(catalogPath, defaultCatalog);
+    return;
+  }
+
+  let existingCatalog;
+  try {
+    existingCatalog = JSON.parse(fs.readFileSync(catalogPath, "utf8"));
+  } catch {
+    return;
+  }
+
+  if (shouldReplaceLegacyCatalog(existingCatalog)) {
+    writeJsonFile(catalogPath, defaultCatalog);
+  }
+}
+
+function shouldReplaceLegacyCatalog(catalog) {
+  if (!catalog || !Array.isArray(catalog.models)) {
+    return false;
+  }
+
+  const slugs = catalog.models
+    .map((model) => model?.slug)
+    .filter((slug) => typeof slug === "string");
+
+  if (slugs.length === 0) {
+    return true;
+  }
+
+  if (slugs.length === 1 && slugs[0] === DEFAULT_MODEL) {
+    return true;
+  }
+
+  for (const qwenModel of catalog.models.filter((model) =>
+    QWEN_MODELS.has(model?.slug),
+  )) {
+    if (
+      qwenModel.apply_patch_tool_type !== "function" ||
+      qwenModel.supports_reasoning_summaries !== false ||
+      qwenModel.support_verbosity !== false ||
+      Object.prototype.hasOwnProperty.call(qwenModel, "default_reasoning_level") ||
+      !Array.isArray(qwenModel.supported_reasoning_levels) ||
+      qwenModel.supported_reasoning_levels.length !== 0
+    ) {
+      return true;
+    }
+  }
+
+  if (!slugs.includes(DEFAULT_MODEL)) {
+    return true;
+  }
+
+  return slugs.some((slug) => LEGACY_MODELS.has(slug));
+}
+
+function ensureInniesConfig(configPath, catalogPath, state) {
+  if (!fs.existsSync(configPath)) {
+    fs.writeFileSync(configPath, defaultInniesConfig(catalogPath, managedDefaultModel()));
+    return defaultInniesState();
+  }
+
+  const existing = fs.readFileSync(configPath, "utf8");
+  const nextState = determineModelSelectionState(existing, state);
+  const updated = normalizeInniesConfig(existing, catalogPath, nextState);
+  if (updated !== existing) {
+    fs.writeFileSync(configPath, updated);
+  }
+  return nextState;
+}
+
+function defaultInniesConfig(catalogPath, managedDefault) {
+  const lines = managedDefault
+    ? managedDefaultLines(catalogPath, managedDefault)
+    : [`model_catalog_json = ${JSON.stringify(catalogPath)}`];
+  return [
+    ...lines,
+    "",
+    defaultZhiman35bProviderBlock(),
+    "",
+    defaultDashscopeProviderBlock(),
+    "",
+  ].join("\n");
+}
+
+function normalizeInniesConfig(contents, catalogPath, state) {
+  if (contents.trim() === "") {
+    return defaultInniesConfig(catalogPath, managedDefaultModel());
+  }
+
+  const isUserSelected =
+    state.model_selection_state === MODEL_SELECTION_STATES.USER_SELECTED;
+  const managedDefault = isUserSelected ? null : managedDefaultModel();
+  const managedSettings = ROOT_MANAGED_SETTINGS;
+  const unmanagedContents = stripManagedRootSettings(contents, managedSettings).trim();
+  const managedLines = isUserSelected
+    ? preservedUserManagedLines(contents, catalogPath)
+    : managedDefault
+      ? managedDefaultLines(catalogPath, managedDefault)
+      : catalogOnlyManagedLines(catalogPath);
+  let updated = `${managedLines.join("\n")}\n`;
+
+  if (unmanagedContents !== "") {
+    updated = `${updated}\n${unmanagedContents}\n`;
+  } else {
+    updated = `${updated}\n`;
+  }
+
+  updated = normalizeManagedProviderBlocks(stripReservedProviderBlocks(updated));
+  if (!updated.includes(ZHIMAN_35B_PROVIDER_HEADER)) {
+    updated = `${updated.trimEnd()}\n\n${defaultZhiman35bProviderBlock()}\n`;
+  }
+  if (!updated.includes(DASHSCOPE_PROVIDER_HEADER)) {
+    updated = `${updated.trimEnd()}\n\n${defaultDashscopeProviderBlock()}\n`;
+  }
+
+  return updated;
+}
+
+function managedDefaultLines(catalogPath, managedDefault) {
+  return [
+    `model_provider = ${JSON.stringify(managedDefault.provider)}`,
+    `model = ${JSON.stringify(managedDefault.model)}`,
+    `model_catalog_json = ${JSON.stringify(catalogPath)}`,
+  ];
+}
+
+function catalogOnlyManagedLines(catalogPath) {
+  return [`model_catalog_json = ${JSON.stringify(catalogPath)}`];
+}
+
+function preservedUserManagedLines(contents, catalogPath) {
+  const preservedModelProvider = readRootSetting(contents, "model_provider");
+  const preservedModel = readRootSetting(contents, "model");
+  const preservedModelValue = extractRootSettingValue(contents, "model");
+  const preservedProviderValue = extractRootSettingValue(contents, "model_provider");
+  const preservesQwenModel =
+    (preservedModelValue === DEFAULT_MODEL &&
+      (preservedProviderValue == null || preservedProviderValue === DEFAULT_PROVIDER)) ||
+    (preservedModelValue === DASHSCOPE_MODEL &&
+      (preservedProviderValue == null || preservedProviderValue === "dashscope"));
+  const preservedEffort = preservesQwenModel
+    ? null
+    : readRootSetting(contents, "model_reasoning_effort");
+
+  return [
+    preservedModelProvider ?? 'model_provider = "openai"',
+    preservedModel ?? 'model = "gpt-5.5"',
+    `model_catalog_json = ${JSON.stringify(catalogPath)}`,
+    ...(preservedEffort ? [preservedEffort] : []),
+  ];
+}
+
+function readRootSetting(contents, key) {
+  const settingPattern = new RegExp(`^\\s*${key}\\s*=.*$`, "m");
+  return contents.match(settingPattern)?.[0] ?? null;
+}
+
+function stripReservedProviderBlocks(contents) {
+  const lines = contents.split(/\r?\n/);
+  const keptLines = [];
+  let skippingReservedBlock = false;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    const isSectionHeader = /^\[[^\]]+\]$/.test(trimmed);
+    if (isSectionHeader) {
+      skippingReservedBlock = RESERVED_PROVIDER_HEADERS.includes(trimmed);
+    }
+    if (!skippingReservedBlock) {
+      keptLines.push(line);
+    }
+  }
+
+  return keptLines.join("\n").replace(/\n{3,}/g, "\n\n").trimEnd();
+}
+
+function determineModelSelectionState(contents, previousState) {
+  const currentModel = extractRootSettingValue(contents, "model");
+  const currentProvider = extractRootSettingValue(contents, "model_provider");
+  if (currentModel == null && currentProvider == null) {
+    return previousState;
+  }
+
+  if (
+    currentModel === DEFAULT_MODEL &&
+    (currentProvider == null || currentProvider === DEFAULT_PROVIDER)
+  ) {
+    return previousState;
+  }
+
+  if (
+    currentModel === DASHSCOPE_MODEL &&
+    (currentProvider == null || currentProvider === "dashscope")
+  ) {
+    return previousState;
+  }
+
+  if (
+    previousState.model_selection_state === MODEL_SELECTION_STATES.MANAGED_DEFAULT &&
+    currentModel === LEGACY_MANAGED_GPT_MODEL &&
+    currentProvider === LEGACY_MANAGED_GPT_PROVIDER &&
+    extractRootSettingValue(contents, "model_reasoning_effort") ===
+      LEGACY_MANAGED_GPT_REASONING
+  ) {
+    return previousState;
+  }
+
+  if (
+    currentModel != null &&
+    !LEGACY_MODELS.has(currentModel) &&
+    (currentModel !== DEFAULT_MODEL || currentProvider !== DEFAULT_PROVIDER) &&
+    (currentModel !== DASHSCOPE_MODEL || currentProvider !== "dashscope")
+  ) {
+    return {
+      model_selection_state: MODEL_SELECTION_STATES.USER_SELECTED,
+    };
+  }
+
+  return previousState;
+}
+
+function extractRootSettingValue(contents, key) {
+  const match = contents.match(new RegExp(`^\\s*${key}\\s*=\\s*\"([^\"]*)\"`, "m"));
+  return match?.[1] ?? null;
+}
+
+function stripManagedRootSettings(contents, managedSettings = ROOT_MANAGED_SETTINGS) {
+  const managedKeys = new Set(managedSettings.map(([key]) => key));
+  const lines = contents.split(/\r?\n/);
+  const keptLines = [];
+  let inRootTable = true;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (/^\[[^\]]+\]$/.test(trimmed)) {
+      inRootTable = false;
+    }
+
+    const rootSetting = line.match(/^\s*([A-Za-z0-9_]+)\s*=/);
+    if (inRootTable && rootSetting && managedKeys.has(rootSetting[1])) {
+      continue;
+    }
+
+    keptLines.push(line);
+  }
+
+  return keptLines.join("\n").replace(/\n{3,}/g, "\n\n");
+}
+
+function managedDefaultModel() {
+  return {
+    provider: DEFAULT_PROVIDER,
+    model: DEFAULT_MODEL,
+  };
+}
+
+function normalizeManagedProviderBlocks(contents) {
+  let updated = normalizeProviderBlock(contents, {
+    providerHeader: ZHIMAN_35B_PROVIDER_HEADER,
+    baseUrl: ZHIMAN_35B_RESPONSES_BASE_URL,
+    envKey: "ZHIMAN_35B_API_KEY",
+  });
+  updated = normalizeProviderBlock(updated, {
+    providerHeader: DASHSCOPE_PROVIDER_HEADER,
+    baseUrl: DASHSCOPE_RESPONSES_BASE_URL,
+    envKey: "DASHSCOPE_API_KEY",
+  });
+  return updated;
+}
+
+function normalizeProviderBlock(contents, provider) {
+  const lines = contents.split(/\r?\n/);
+  const updated = [];
+  let inProviderBlock = false;
+  let sawBaseUrl = false;
+  let sawWireApi = false;
+  let sawEnvKey = false;
+  let sawBearerToken = false;
+
+  const finishProviderBlock = () => {
+    if (!inProviderBlock) {
+      return;
+    }
+    if (!sawBaseUrl) {
+      updated.push(`base_url = ${JSON.stringify(provider.baseUrl)}`);
+    }
+    if (!sawWireApi) {
+      updated.push('wire_api = "responses"');
+    }
+    if (!sawEnvKey) {
+      updated.push(`env_key = ${JSON.stringify(provider.envKey)}`);
+    }
+  };
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    const isSectionHeader = /^\[[^\]]+\]$/.test(trimmed);
+    if (isSectionHeader) {
+      finishProviderBlock();
+      inProviderBlock = trimmed === provider.providerHeader;
+      sawBaseUrl = false;
+      sawWireApi = false;
+      sawEnvKey = false;
+      sawBearerToken = false;
+      updated.push(line);
+      continue;
+    }
+
+    if (inProviderBlock) {
+      if (/^\s*base_url\s*=/.test(line)) {
+        updated.push(`base_url = ${JSON.stringify(provider.baseUrl)}`);
+        sawBaseUrl = true;
+        continue;
+      }
+      if (/^\s*wire_api\s*=/.test(line)) {
+        updated.push('wire_api = "responses"');
+        sawWireApi = true;
+        continue;
+      }
+      if (/^\s*env_key\s*=/.test(line)) {
+        updated.push(`env_key = ${JSON.stringify(provider.envKey)}`);
+        sawEnvKey = true;
+        continue;
+      }
+      if (/^\s*experimental_bearer_token\s*=/.test(line)) {
+        updated.push(line);
+        sawBearerToken = true;
+        continue;
+      }
+    }
+
+    updated.push(line);
+  }
+
+  finishProviderBlock();
+  return updated.join("\n").replace(/\n{3,}/g, "\n\n").trimEnd();
+}
+
+function defaultZhiman35bProviderBlock() {
+  return [
+    ZHIMAN_35B_PROVIDER_HEADER,
+    'name = "zhiman_35b"',
+    `base_url = ${JSON.stringify(ZHIMAN_35B_RESPONSES_BASE_URL)}`,
+    'wire_api = "responses"',
+    'env_key = "ZHIMAN_35B_API_KEY"',
+  ].join("\n");
+}
+
+function defaultDashscopeProviderBlock() {
+  return [
+    DASHSCOPE_PROVIDER_HEADER,
+    'name = "DashScope"',
+    `base_url = ${JSON.stringify(DASHSCOPE_RESPONSES_BASE_URL)}`,
+    'wire_api = "responses"',
+    'env_key = "DASHSCOPE_API_KEY"',
+  ].join("\n");
+}

package/bin/innies-init.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+
+import { ensureInniesHomeDefaults, resolveInniesHome } from "./innies-config.js";
+
+const codexHome = resolveInniesHome();
+fs.mkdirSync(codexHome, { recursive: true });
+ensureInniesHomeDefaults(codexHome);

package/bin/innies.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import path from "node:path";
+
+import { maybeRunInniesCodingRuntime } from "./innies-coding-runtime.js";
+import { ensureInniesHomeDefaults, resolveInniesHome } from "./innies-config.js";
+
+const INNIES_HOME_ENV_VAR = "INNIES_HOME";
+
+function isVersionRequest(args) {
+  return args.length === 1 && (args[0] === "--version" || args[0] === "-V");
+}
+
+if (isVersionRequest(process.argv.slice(2))) {
+  const packageJson = JSON.parse(
+    fs.readFileSync(new URL("../package.json", import.meta.url), "utf8"),
+  );
+  const runtimeVersion = `innies-cli ${packageJson.version}`;
+  writeExternalRuntimeSmokeResult(runtimeVersion);
+  console.log(runtimeVersion);
+  process.exit(0);
+}
+
+const codexHome = resolveInniesHome();
+process.env[INNIES_HOME_ENV_VAR] = codexHome;
+process.env.CODEX_HOME = codexHome;
+fs.mkdirSync(codexHome, { recursive: true });
+
+ensureInniesHomeDefaults(codexHome);
+
+if (await maybeRunInniesCodingRuntime()) {
+  process.exit(0);
+}
+
+await import("./codex.js");
+
+function writeExternalRuntimeSmokeResult(runtimeVersion) {
+  if (process.env.INNIES_CODING_STAGE !== "external_runtime_smoke") {
+    return;
+  }
+  const resultFile = process.env.INNIES_CODING_AGENT_RUN_RESULT_FILE;
+  if (!resultFile) {
+    return;
+  }
+
+  fs.mkdirSync(path.dirname(resultFile), { recursive: true });
+  fs.writeFileSync(
+    resultFile,
+    `${JSON.stringify(
+      {
+        stage: "external_runtime_smoke",
+        status: "success",
+        input_metadata_json: {
+          workflow_id: process.env.INNIES_CODING_WORKFLOW_ID || null,
+          runtime_version: runtimeVersion,
+        },
+        output_artifact_list: [
+          {
+            artifact_type: "external_runtime_smoke",
+            status: "generated",
+            content_json: {
+              runtime_version: runtimeVersion,
+            },
+            metadata_json: {
+              workflow_id: process.env.INNIES_CODING_WORKFLOW_ID || null,
+            },
+          },
+        ],
+        failure_context_json: {},
+      },
+      null,
+      2,
+    )}\n`,
+    "utf8",
+  );
+}