@aion0/forge 0.10.6 → 0.10.17

package/lib/public-info/types.ts

@@ -0,0 +1,38 @@
+/**
+ * Shapes of JSON resources served from the public-info repo
+ * (https://github.com/aiwatching/forge-public-info, by default).
+ *
+ * Each resource lives under `<repoUrl>/<resource-dir>/<file>.json` so new
+ * resource types can be added without touching settings. Forge fetches
+ * them via `lib/public-info/fetch.ts` (24h cache + built-in fallback).
+ */
+
+export interface ModelInfo {
+  id: string;
+  label: string;
+  /** Rough quality/cost band — used by UI to sort/group. */
+  tier?: 'premium' | 'standard' | 'fast';
+  default?: boolean;
+}
+
+export interface ModelAlias {
+  id: string;
+  label: string;
+}
+
+export interface AgentModels {
+  displayName: string;
+  default: string;
+  aliases: ModelAlias[];
+  models: ModelInfo[];
+}
+
+export interface ModelsRegistry {
+  version: number;
+  updatedAt: string;
+  note?: string;
+  /** Keyed by CLI type (e.g. `claude-code`, `codex`, `aider`). */
+  agents: Record<string, AgentModels>;
+  /** Keyed by API provider id (e.g. `anthropic`, `openai`, `grok`, `google`, `deepseek`, `litellm`). */
+  providers?: Record<string, AgentModels>;
+}

package/lib/public-info/use-models-registry.ts

@@ -0,0 +1,66 @@
+/**
+ * Client-side hook for the model registry. Lazy-fetches from
+ * `GET /api/public-info/models`, caches in module-level state so
+ * multiple components sharing the registry hit the network once per
+ * page load. Returns the bundled fallback shape until the network
+ * round-trip completes so callers never see `undefined`.
+ */
+
+'use client';
+
+import { useEffect, useState } from 'react';
+import { KNOWN_MODELS_FALLBACK } from '../agents/known-models';
+import type { ModelsRegistry, AgentModels } from './types';
+
+let cached: ModelsRegistry | null = null;
+let inflight: Promise<ModelsRegistry> | null = null;
+
+async function load(refresh = false): Promise<ModelsRegistry> {
+  if (cached && !refresh) return cached;
+  if (inflight && !refresh) return inflight;
+  inflight = (async () => {
+    try {
+      const res = await fetch(`/api/public-info/models${refresh ? '?refresh=1' : ''}`);
+      if (res.ok) {
+        const data = await res.json();
+        cached = data as ModelsRegistry;
+        return cached;
+      }
+    } catch {}
+    cached = KNOWN_MODELS_FALLBACK;
+    return cached;
+  })();
+  try { return await inflight; } finally { inflight = null; }
+}
+
+export function useModelsRegistry(): {
+  registry: ModelsRegistry;
+  refresh: () => Promise<void>;
+  loading: boolean;
+} {
+  const [registry, setRegistry] = useState<ModelsRegistry>(cached ?? KNOWN_MODELS_FALLBACK);
+  const [loading, setLoading] = useState(!cached);
+
+  useEffect(() => {
+    if (cached) return;
+    setLoading(true);
+    load().then(r => { setRegistry(r); setLoading(false); });
+  }, []);
+
+  async function refresh() {
+    setLoading(true);
+    const r = await load(true);
+    setRegistry(r);
+    setLoading(false);
+  }
+
+  return { registry, refresh, loading };
+}
+
+/** Get the model option list for a specific agent CLI type. Returns the
+ *  flat list of `[...aliases, ...models]` as the picker expects them. */
+export function pickerOptions(registry: ModelsRegistry, cliType: string): string[] {
+  const agent: AgentModels | undefined = registry.agents[cliType];
+  if (!agent) return ['default'];
+  return [...agent.aliases.map(a => a.id), ...agent.models.map(m => m.id)];
+}

package/lib/settings.ts

@@ -27,10 +27,11 @@ export interface AgentEntry {
   models?: { terminal?: string; task?: string; telegram?: string; help?: string; mobile?: string };
   skipPermissionsFlag?: string;
   requiresTTY?: boolean;
-  model?: string;                // flat model override
   env?: Record<string, string>;  // environment variables injected when spawning CLI
 
   // === Deprecated (kept for migration compat; removed in a later release) ===
+  /** @deprecated 顶层 model 被 models.terminal/task/... 子表替代,migrate.ts 自动清掉 */
+  model?: string;
   /** @deprecated migrated to `tool` */
   base?: string;
   /** @deprecated migrated to `tool` */
@@ -84,7 +85,9 @@ export interface Settings {
   projectRoots: string[];
   docRoots: string[];
   claudePath: string;
-  claudeHome: string;
+  // claudeHome removed in 0.10.10 — was a never-UI-exposed override that
+  // mostly served to leak `claudeHome: ""` into every yaml. Set the
+  // CLAUDE_HOME env var if you need to point at a non-default ~/.claude.
   telegramBotToken: string;
   telegramChatId: string;
   notifyOnComplete: boolean;
@@ -109,6 +112,14 @@ export interface Settings {
    * shape as connectorsRepoUrl. Default: `aiwatching/forge-workflow`.
    */
   workflowRepoUrl: string;
+  /**
+   * Base URL for the `forge-public-info` repo. Houses model lists and
+   * other small JSON files that the maintainer updates between npm
+   * releases — push a JSON commit, all users pick it up within 24h via
+   * the cache. Sub-paths (e.g. `models/registry.json`) are appended by
+   * `lib/public-info/fetch.ts`. Default: `aiwatching/forge-public-info`.
+   */
+  publicInfoRepoUrl: string;
   /**
    * Maximum concurrent pipeline runs (running + pending). When a Job's
    * scheduler tick would push the total above this, additional items
@@ -184,7 +195,11 @@ const defaults: Settings = {
   projectRoots: [],
   docRoots: [],
   claudePath: '',
-  claudeHome: '',
+  // claudeHome intentionally omitted — it's an optional override (most users
+  // have claude at ~/.claude). Keeping it as a default empty string used to
+  // leak `claudeHome: ""` into every saved settings.yaml, which the dirs.ts
+  // regex then mis-parsed as the value `"`. See loadSettings normalizer +
+  // dirs.ts:getClaudeDir for the read-side handling.
   telegramBotToken: '',
   telegramChatId: '',
   notifyOnComplete: true,
@@ -200,6 +215,7 @@ const defaults: Settings = {
   skillsRepoUrl: 'https://raw.githubusercontent.com/aiwatching/forge-skills/main',
   connectorsRepoUrl: 'https://raw.githubusercontent.com/aiwatching/forge-connectors/main',
   workflowRepoUrl: 'https://raw.githubusercontent.com/aiwatching/forge-workflow/main',
+  publicInfoRepoUrl: 'https://raw.githubusercontent.com/aiwatching/forge-public-info/main',
   maxConcurrentPipelines: 5,
   displayName: 'Forge',
   displayEmail: '',
@@ -279,7 +295,21 @@ export function loadSettings(): Settings {
   if (!existsSync(SETTINGS_FILE)) return { ...defaults };
   try {
     const raw = readFileSync(SETTINGS_FILE, 'utf-8');
-    const parsed = { ...defaults, ...YAML.parse(raw) };
+    const parsed: any = { ...defaults, ...YAML.parse(raw) };
+    // claudeHome was removed from the schema in 0.10.10. Drop any leftover
+    // value so it stops round-tripping through saveSettings. If a user had
+    // set a real override (rare — UI never exposed the field), surface a
+    // one-time warning pointing them at the CLAUDE_HOME env var.
+    if ('claudeHome' in parsed) {
+      const old = parsed.claudeHome;
+      delete parsed.claudeHome;
+      if (old && old !== '') {
+        console.warn(
+          `[settings] claudeHome="${old}" is no longer read. ` +
+          `If you need to override the claude config dir, set CLAUDE_HOME env var instead.`,
+        );
+      }
+    }
     // Decrypt top-level secret fields
     for (const field of SECRET_FIELDS) {
       if (parsed[field] && isEncrypted(parsed[field])) {

package/lib/skills.ts

@@ -8,6 +8,7 @@ import { homedir } from 'node:os';
 import { getDb } from '../src/core/db/database';
 import { getDbPath } from '../src/config';
 import { loadSettings } from './settings';
+import { getClaudeDir } from './dirs';
 
 type ItemType = 'skill' | 'command';
 
@@ -271,8 +272,7 @@ async function downloadFile(url: string): Promise<string> {
 // ─── Install ─────────────────────────────────────────────────
 
 function getClaudeHome(): string {
-  const settings = loadSettings();
-  return settings.claudeHome || join(homedir(), '.claude');
+  return getClaudeDir();
 }
 
 function getSkillDir(name: string, type: ItemType, projectPath?: string): string {

package/lib/workspace/watch-manager.ts

@@ -13,6 +13,7 @@ import { homedir } from 'node:os';
 import { execSync } from 'node:child_process';
 import type { WorkspaceAgentConfig, WatchTarget, WatchConfig } from './types';
 import { appendAgentLog } from './persistence';
+import { getClaudeDir } from '../dirs';
 
 // ─── Snapshot types ──────────────────────────────────────
 
@@ -219,7 +220,10 @@ function detectAgentLogChanges(workspaceId: string, targetAgentId: string, patte
 const lastSessionFile = new Map<string, string>();
 
 function detectSessionChanges(projectPath: string, pattern: string | undefined, prevLineCount: number, contextChars = 500, sessionId?: string): { changes: WatchChange | null; lineCount: number } {
-  const claudeHome = join(homedir(), '.claude', 'projects');
+  // Honor CLAUDE_HOME env var so watch-manager looks in the same place as
+  // session detection, skills installer, etc. Was previously hardcoded to
+  // ~/.claude, which silently broke for users with a custom claude dir.
+  const claudeHome = join(getClaudeDir(), 'projects');
   const encoded = projectPath.replace(/[^a-zA-Z0-9]/g, '-');
   const sessionDir = join(claudeHome, encoded);
   if (!existsSync(sessionDir)) return { changes: null, lineCount: prevLineCount };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aion0/forge",
-  "version": "0.10.6",
+  "version": "0.10.17",
   "description": "Unified AI workflow platform — multi-model task orchestration, persistent sessions, web terminal, remote access",
   "type": "module",
   "scripts": {

package/lib/__tests__/foreach-batch-yaml.test.ts

@@ -1,33 +0,0 @@
-/**
- * Smoke test: fortinet-mr-review-batch v0.3.0 parses end-to-end through
- * parseWorkflow with the new for_each.before extension.
- */
-import { parseWorkflow } from '../pipeline';
-import { readFileSync } from 'fs';
-
-const txt = readFileSync('/Users/zliu/.forge/data/flows/fortinet-mr-review-batch.yaml', 'utf8');
-const wf = parseWorkflow(txt);
-
-let ok = true;
-function eq(actual: any, expected: any, label: string) {
-  if (JSON.stringify(actual) === JSON.stringify(expected)) {
-    console.log(`  ✓ ${label}`);
-  } else {
-    console.log(`  ✗ ${label}: got ${JSON.stringify(actual)}, want ${JSON.stringify(expected)}`);
-    ok = false;
-  }
-}
-
-console.log('fortinet-mr-review-batch v0.3.0 — parseWorkflow integration');
-eq(wf.name, 'fortinet-mr-review-batch', 'workflow name');
-eq(wf.for_each?.source, '{{nodes.list-iids.outputs.iids}}', 'for_each.source');
-eq(wf.for_each?.as, 'mr_iid', 'for_each.as');
-eq(wf.for_each?.on_failure, 'continue', 'for_each.on_failure');
-eq(wf.for_each?.before, ['list-iids'], 'for_each.before');
-eq(Object.keys(wf.nodes), ['list-iids', 'ingest', 'triage', 'fix', 'reply', 'cleanup'], 'all 6 nodes parsed');
-eq(wf.nodes['list-iids']?.mode, 'shell', 'list-iids mode = shell');
-eq(wf.nodes['list-iids']?.worktree, false, 'list-iids worktree = false');
-eq(wf.nodes['list-iids']?.outputs?.[0]?.name, 'iids', 'list-iids outputs.iids name');
-eq(wf.nodes['list-iids']?.outputs?.[0]?.extract, 'stdout', 'list-iids outputs.iids extract');
-
-process.exit(ok ? 0 : 1);

package/lib/__tests__/foreach-before.test.ts

@@ -1,201 +0,0 @@
-/**
- * for_each.before: tests — covers:
- *   - parseWorkflow validates `before:` field shape + node existence
- *   - parseForEach passes through `before:` correctly
- *   - resolveForEachSource accepts node outputs (`{{nodes.X.outputs.Y}}`)
- *
- * Setup-phase orchestration (startPipeline scheduling, checkPipelineCompletion
- * transition) needs running tasks + file system + scheduler — not unit-testable
- * here. Verified end-to-end in fortinet-mr-review-batch v0.3.0.
- *
- * Run:  npx tsx lib/__tests__/foreach-before.test.ts
- */
-
-import { parseWorkflow, resolveForEachSource } from '../pipeline';
-
-let passed = 0, failed = 0;
-function check(name: string, fn: () => void) {
-  try { fn(); console.log(`  ✓ ${name}`); passed++; }
-  catch (e) { console.log(`  ✗ ${name}\n    ${(e as Error).message}`); failed++; }
-}
-function expectThrow(fn: () => void, msgIncludes: string) {
-  try { fn(); throw new Error(`expected throw containing "${msgIncludes}"`); }
-  catch (e) {
-    const m = (e as Error).message;
-    if (!m.includes(msgIncludes)) throw new Error(`got "${m}", expected to include "${msgIncludes}"`);
-  }
-}
-function eqArr(a: unknown[], b: unknown[], label = '') {
-  if (a.length !== b.length || a.some((v, i) => v !== b[i])) {
-    throw new Error(`${label}: expected ${JSON.stringify(b)}, got ${JSON.stringify(a)}`);
-  }
-}
-
-console.log('for_each.before parsing + node-output source resolution tests');
-
-// ── parseForEach / parseWorkflow: shape + validation ──
-
-check('parseWorkflow accepts valid before: [<node>]', () => {
-  const wf = parseWorkflow(`
-name: test
-for_each:
-  source: "{{nodes.list-ids.outputs.ids}}"
-  as: id
-  before: [list-ids]
-nodes:
-  list-ids:
-    project: x
-    prompt: "echo 1,2,3"
-  body:
-    project: x
-    prompt: "consume {{id}}"
-    depends_on: [list-ids]
-`);
-  if (!wf.for_each) throw new Error('for_each missing');
-  if (!wf.for_each.before) throw new Error('before missing');
-  eqArr(wf.for_each.before, ['list-ids']);
-});
-
-check('parseWorkflow accepts multi-node before: [a, b]', () => {
-  const wf = parseWorkflow(`
-name: test
-for_each:
-  source: "{{nodes.b.outputs.list}}"
-  as: x
-  before: [a, b]
-nodes:
-  a: { project: x, prompt: "1" }
-  b: { project: x, prompt: "2", depends_on: [a] }
-  body: { project: x, prompt: "{{x}}" }
-`);
-  eqArr(wf.for_each!.before!, ['a', 'b']);
-});
-
-check('parseWorkflow with NO before: → before undefined (back-compat)', () => {
-  const wf = parseWorkflow(`
-name: test
-for_each:
-  source: "{{input.ids}}"
-  as: id
-nodes:
-  body: { project: x, prompt: "{{id}}" }
-`);
-  if (wf.for_each!.before !== undefined) throw new Error(`expected undefined, got ${JSON.stringify(wf.for_each!.before)}`);
-});
-
-check('parseWorkflow throws on before referencing unknown node', () => {
-  expectThrow(() => parseWorkflow(`
-name: test
-for_each:
-  source: "{{nodes.missing.outputs.x}}"
-  as: id
-  before: [missing]
-nodes:
-  body: { project: x, prompt: "1" }
-`), "references unknown node id 'missing'");
-});
-
-check('parseWorkflow throws on before: not-an-array', () => {
-  expectThrow(() => parseWorkflow(`
-name: test
-for_each:
-  source: "{{nodes.list-ids.outputs.x}}"
-  as: id
-  before: "list-ids"
-nodes:
-  list-ids: { project: x, prompt: "1" }
-  body: { project: x, prompt: "{{id}}" }
-`), 'must be an array of node id strings');
-});
-
-check('parseWorkflow throws on before: [empty-string]', () => {
-  expectThrow(() => parseWorkflow(`
-name: test
-for_each:
-  source: "{{nodes.x.outputs.x}}"
-  as: id
-  before: [""]
-nodes:
-  x: { project: x, prompt: "1" }
-  body: { project: x, prompt: "{{id}}" }
-`), 'must be an array of node id strings');
-});
-
-check('parseWorkflow throws on before: [non-string]', () => {
-  expectThrow(() => parseWorkflow(`
-name: test
-for_each:
-  source: "{{nodes.x.outputs.x}}"
-  as: id
-  before: [123]
-nodes:
-  x: { project: x, prompt: "1" }
-  body: { project: x, prompt: "{{id}}" }
-`), 'must be an array of node id strings');
-});
-
-// ── resolveForEachSource: ctx now includes nodes ──
-
-check('resolveForEachSource reads {{nodes.X.outputs.Y}} from pipeline.nodes', () => {
-  const nodes = {
-    'list-ids': { status: 'done' as const, outputs: { ids: '7,8,9' }, iterations: 0 },
-  };
-  const items = resolveForEachSource(
-    { source: '{{nodes.list-ids.outputs.ids}}' },
-    {},
-    {},
-    nodes,
-  );
-  eqArr(items, ['7', '8', '9']);
-});
-
-check('resolveForEachSource trims whitespace from node-output split items', () => {
-  const nodes = {
-    'list-ids': { status: 'done' as const, outputs: { ids: ' 1, 2 ,3 ' }, iterations: 0 },
-  };
-  const items = resolveForEachSource(
-    { source: '{{nodes.list-ids.outputs.ids}}' },
-    {},
-    {},
-    nodes,
-  );
-  eqArr(items, ['1', '2', '3']);
-});
-
-check('resolveForEachSource empty node output → empty array', () => {
-  const nodes = {
-    'list-ids': { status: 'done' as const, outputs: { ids: '' }, iterations: 0 },
-  };
-  const items = resolveForEachSource(
-    { source: '{{nodes.list-ids.outputs.ids}}' },
-    {},
-    {},
-    nodes,
-  );
-  eqArr(items, []);
-});
-
-check('resolveForEachSource with custom split + node output', () => {
-  const nodes = {
-    'list-ids': { status: 'done' as const, outputs: { ids: 'a|b|c' }, iterations: 0 },
-  };
-  const items = resolveForEachSource(
-    { source: '{{nodes.list-ids.outputs.ids}}', split: '|' },
-    {},
-    {},
-    nodes,
-  );
-  eqArr(items, ['a', 'b', 'c']);
-});
-
-check('resolveForEachSource without nodes param (back-compat) still works', () => {
-  const items = resolveForEachSource(
-    { source: '{{input.ids}}' },
-    { ids: '1,2' },
-    {},
-  );
-  eqArr(items, ['1', '2']);
-});
-
-console.log(`\n${passed} passed, ${failed} failed`);
-process.exit(failed === 0 ? 0 : 1);

package/lib/__tests__/foreach-parse.test.ts

@@ -1,114 +0,0 @@
-/**
- * Step-2 verification: parseWorkflow handles `for_each:` correctly.
- *
- * No test framework — just a tsx script that throws on first failure.
- * Run:  npx tsx lib/__tests__/foreach-parse.test.ts
- */
-
-import { parseWorkflow } from '../pipeline';
-
-let passed = 0;
-let failed = 0;
-
-function check(name: string, fn: () => void) {
-  try { fn(); console.log(`  ✓ ${name}`); passed++; }
-  catch (e) { console.log(`  ✗ ${name}\n    ${(e as Error).message}`); failed++; }
-}
-
-function expectThrow(yaml: string, expectedSubstring: string) {
-  try {
-    parseWorkflow(yaml);
-    throw new Error(`expected throw containing "${expectedSubstring}", got none`);
-  } catch (e) {
-    const msg = (e as Error).message;
-    if (!msg.includes(expectedSubstring)) {
-      throw new Error(`expected throw containing "${expectedSubstring}", got: ${msg}`);
-    }
-  }
-}
-
-console.log('parseWorkflow + for_each: parser tests');
-
-check('no for_each → workflow.for_each is undefined', () => {
-  const w = parseWorkflow('name: foo\nnodes:\n  a: { project: x, prompt: "echo hi" }\n');
-  if (w.for_each !== undefined) throw new Error(`expected undefined, got ${JSON.stringify(w.for_each)}`);
-});
-
-check('valid for_each with string source', () => {
-  const w = parseWorkflow(`
-name: foo
-for_each:
-  source: "{{input.ids}}"
-  as: bug_id
-nodes:
-  a: { project: x, prompt: "echo {{bug_id}}" }
-`);
-  if (!w.for_each) throw new Error('for_each missing');
-  if (w.for_each.source !== '{{input.ids}}') throw new Error('source wrong');
-  if (w.for_each.as !== 'bug_id') throw new Error('as wrong');
-  if (w.for_each.on_failure !== 'continue') throw new Error(`on_failure default should be continue, got ${w.for_each.on_failure}`);
-});
-
-check('default as = "item"', () => {
-  const w = parseWorkflow('name: foo\nfor_each:\n  source: "{{input.x}}"\nnodes:\n  a: { project: x, prompt: "" }\n');
-  if (w.for_each!.as !== 'item') throw new Error('default as should be item');
-});
-
-check('on_failure: stop accepted', () => {
-  const w = parseWorkflow('name: foo\nfor_each:\n  source: x\n  on_failure: stop\nnodes:\n  a: { project: x, prompt: "" }\n');
-  if (w.for_each!.on_failure !== 'stop') throw new Error('on_failure not preserved');
-});
-
-check('array source literal', () => {
-  const w = parseWorkflow('name: foo\nfor_each:\n  source: [1, 2, 3]\nnodes:\n  a: { project: x, prompt: "" }\n');
-  if (!Array.isArray(w.for_each!.source)) throw new Error('array literal not preserved');
-  if ((w.for_each!.source as any[]).length !== 3) throw new Error('array length wrong');
-});
-
-check('split: ";" accepted', () => {
-  const w = parseWorkflow('name: foo\nfor_each:\n  source: x\n  split: ";"\nnodes:\n  a: { project: x, prompt: "" }\n');
-  if (w.for_each!.split !== ';') throw new Error('split not preserved');
-});
-
-console.log('\nError-path tests:');
-
-check('throws on missing source', () => {
-  expectThrow('name: foo\nfor_each:\n  as: bug\nnodes:\n  a: { project: x, prompt: "" }\n', 'source is required');
-});
-
-check('throws on invalid as identifier', () => {
-  expectThrow('name: foo\nfor_each:\n  source: x\n  as: "bad-name"\nnodes:\n  a: { project: x, prompt: "" }\n', 'must be a valid identifier');
-});
-
-check('throws on reserved as: input', () => {
-  expectThrow('name: foo\nfor_each:\n  source: x\n  as: input\nnodes:\n  a: { project: x, prompt: "" }\n', 'reserved template namespace');
-});
-
-check('throws on reserved as: run', () => {
-  expectThrow('name: foo\nfor_each:\n  source: x\n  as: run\nnodes:\n  a: { project: x, prompt: "" }\n', 'reserved template namespace');
-});
-
-check('throws on bad on_failure value', () => {
-  expectThrow('name: foo\nfor_each:\n  source: x\n  on_failure: maybe\nnodes:\n  a: { project: x, prompt: "" }\n', "must be 'continue' or 'stop'");
-});
-
-check('throws on for_each on conversation type', () => {
-  expectThrow(`
-name: foo
-type: conversation
-for_each:
-  source: x
-agents:
-  - id: a
-    agent: claude
-initial_prompt: hi
-nodes: {}
-`, "only supported on type='dag'");
-});
-
-check('throws on for_each scalar (not object)', () => {
-  expectThrow('name: foo\nfor_each: "{{input.ids}}"\nnodes:\n  a: { project: x, prompt: "" }\n', 'must be an object');
-});
-
-console.log(`\n${passed} passed, ${failed} failed`);
-process.exit(failed === 0 ? 0 : 1);