@aion0/forge 0.10.12 → 0.10.18

package/lib/settings.ts

@@ -112,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
@@ -207,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: '',

package/next-env.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="next" />
 /// <reference types="next/image-types/global" />
-import "./.next/dev/types/routes.d.ts";
+import "./.next/types/routes.d.ts";
 
 // NOTE: This file should not be edited
 // see https://nextjs.org/docs/app/api-reference/config/typescript for more information.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aion0/forge",
-  "version": "0.10.12",
+  "version": "0.10.18",
   "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);

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

@@ -1,112 +0,0 @@
-/**
- * Step-5 verification: snapshotIteration captures node states + correctly
- * advances the iterations[] history. (Full checkPipelineCompletion has
- * filesystem + scheduling side effects — exercised end-to-end in Step 7.)
- *
- * Run:  npx tsx lib/__tests__/foreach-snapshot.test.ts
- */
-
-import { snapshotIteration } 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 makePipeline(items: unknown[], currentIndex = 0): any {
-  return {
-    id: 'test123',
-    workflowName: 'test',
-    status: 'running',
-    input: {},
-    vars: {},
-    nodes: {
-      a: { status: 'done', outputs: { x: '1' } },
-      b: { status: 'done', outputs: { y: '2' }, error: undefined },
-    },
-    nodeOrder: ['a', 'b'],
-    createdAt: '2026-01-01T00:00:00.000Z',
-    forEach: {
-      items,
-      currentIndex,
-      total: items.length,
-      asName: 'item',
-      onFailure: 'continue',
-      iterations: [],
-    },
-  };
-}
-
-console.log('snapshotIteration tests');
-
-check('snapshot captures all-done nodes with status="done"', () => {
-  const p = makePipeline([1, 2, 3]);
-  snapshotIteration(p, false);
-  if (p.forEach.iterations.length !== 1) throw new Error('iterations length wrong');
-  const iter = p.forEach.iterations[0];
-  if (iter.status !== 'done') throw new Error(`status wrong: ${iter.status}`);
-  if (iter.index !== 0) throw new Error('index wrong');
-  if (iter.nodes.a.status !== 'done') throw new Error('node a status wrong');
-  if (iter.nodes.a.outputs.x !== '1') throw new Error('node a output not preserved');
-});
-
-check('snapshot captures failed iter with status="failed"', () => {
-  const p = makePipeline([1, 2]);
-  p.nodes.b.status = 'failed';
-  p.nodes.b.error = 'boom';
-  snapshotIteration(p, true);
-  const iter = p.forEach.iterations[0];
-  if (iter.status !== 'failed') throw new Error(`status wrong: ${iter.status}`);
-  if (iter.nodes.b.error !== 'boom') throw new Error('error not preserved');
-});
-
-check('startedAt = createdAt for first iter', () => {
-  const p = makePipeline([1, 2]);
-  snapshotIteration(p, false);
-  if (p.forEach.iterations[0].startedAt !== p.createdAt) throw new Error('first startedAt should = createdAt');
-});
-
-check('startedAt = previous completedAt for subsequent iters', () => {
-  const p = makePipeline([1, 2]);
-  snapshotIteration(p, false);
-  const firstCompleted = p.forEach.iterations[0].completedAt;
-  p.forEach.currentIndex = 1;
-  snapshotIteration(p, false);
-  if (p.forEach.iterations[1].startedAt !== firstCompleted) {
-    throw new Error('second iter startedAt should chain from prev completedAt');
-  }
-});
-
-check('outputs are deep-copied (mutation safety)', () => {
-  const p = makePipeline([1]);
-  snapshotIteration(p, false);
-  const iter = p.forEach.iterations[0];
-  // Mutate live node — snapshot should NOT change
-  p.nodes.a.outputs.x = 'MUTATED';
-  if (iter.nodes.a.outputs.x !== '1') throw new Error('snapshot was mutated; need defensive copy');
-});
-
-check('multiple iterations accumulate', () => {
-  const p = makePipeline([1, 2, 3]);
-  snapshotIteration(p, false);
-  p.forEach.currentIndex = 1;
-  snapshotIteration(p, false);
-  p.forEach.currentIndex = 2;
-  snapshotIteration(p, true);
-  if (p.forEach.iterations.length !== 3) throw new Error('expected 3 iters');
-  if (p.forEach.iterations[2].status !== 'failed') throw new Error('iter 3 should be failed');
-  if (p.forEach.iterations[0].index !== 0) throw new Error('iter 0 index wrong');
-  if (p.forEach.iterations[1].index !== 1) throw new Error('iter 1 index wrong');
-  if (p.forEach.iterations[2].index !== 2) throw new Error('iter 2 index wrong');
-});
-
-check('no-op when pipeline.forEach undefined', () => {
-  const p: any = { id: 'x', nodes: {}, createdAt: '2026-01-01' };
-  snapshotIteration(p, false);
-  // Should not throw, should not add anything
-  if (p.forEach !== undefined) throw new Error('should leave forEach undefined');
-});
-
-console.log(`\n${passed} passed, ${failed} failed`);
-process.exit(failed === 0 ? 0 : 1);

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

@@ -1,105 +0,0 @@
-/**
- * Step-4 verification: resolveForEachSource resolves + splits items.
- * Run:  npx tsx lib/__tests__/foreach-source.test.ts
- */
-
-import { 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 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('resolveForEachSource tests');
-
-check('string source via {{input.x}} template, default split=","', () => {
-  const items = resolveForEachSource(
-    { source: '{{input.ids}}' },
-    { ids: '111,222,333' },
-    {},
-  );
-  eqArr(items, ['111', '222', '333']);
-});
-
-check('string source with whitespace around commas — trimmed', () => {
-  const items = resolveForEachSource(
-    { source: '{{input.ids}}' },
-    { ids: ' 111 ,222 , 333  ' },
-    {},
-  );
-  eqArr(items, ['111', '222', '333']);
-});
-
-check('string source with empty entries dropped', () => {
-  const items = resolveForEachSource(
-    { source: '{{input.ids}}' },
-    { ids: '111,,222, ,333,' },
-    {},
-  );
-  eqArr(items, ['111', '222', '333']);
-});
-
-check('empty input.ids → empty array', () => {
-  const items = resolveForEachSource({ source: '{{input.ids}}' }, { ids: '' }, {});
-  eqArr(items, []);
-});
-
-check('input missing → empty string template → empty array', () => {
-  const items = resolveForEachSource({ source: '{{input.missing}}' }, {}, {});
-  eqArr(items, []);
-});
-
-check('custom split: ";"', () => {
-  const items = resolveForEachSource(
-    { source: '{{input.ids}}', split: ';' },
-    { ids: '111;222;333' },
-    {},
-  );
-  eqArr(items, ['111', '222', '333']);
-});
-
-check('array literal source — used as-is', () => {
-  const items = resolveForEachSource(
-    { source: ['a', 'b', 'c'] },
-    {},
-    {},
-  );
-  eqArr(items, ['a', 'b', 'c']);
-});
-
-check('array literal with objects — preserved', () => {
-  const items = resolveForEachSource(
-    { source: [{ iid: 1 }, { iid: 2 }] },
-    {},
-    {},
-  );
-  if (items.length !== 2) throw new Error('length wrong');
-  if ((items[0] as any).iid !== 1) throw new Error('first item wrong');
-});
-
-check('vars source resolves', () => {
-  const items = resolveForEachSource(
-    { source: '{{vars.list}}' },
-    {},
-    { list: 'a,b,c' },
-  );
-  eqArr(items, ['a', 'b', 'c']);
-});
-
-check('literal string with no template, just split', () => {
-  const items = resolveForEachSource(
-    { source: 'foo,bar' },
-    {},
-    {},
-  );
-  eqArr(items, ['foo', 'bar']);
-});
-
-console.log(`\n${passed} passed, ${failed} failed`);
-process.exit(failed === 0 ? 0 : 1);