@aion0/forge 0.10.35 → 0.10.36

package/README.md

@@ -27,6 +27,14 @@
 
 ## Install
 
+**One-liner** (macOS + Linux — installs node deps, tmux, claude code, then Forge):
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/aiwatching/forge/main/scripts/install-deps.sh | bash
+```
+
+Or manually:
+
 ```bash
 npm install -g @aion0/forge
 forge server start
@@ -35,6 +43,7 @@ forge server start
 Open `http://localhost:8403`. First launch prompts you to set an admin password.
 
 **Requirements:** Node.js ≥ 20, tmux, [Claude Code CLI](https://docs.anthropic.com/en/docs/claude-code)
+**Optional:** jq, glab, gh (used by some pipelines)
 
 ## What is Forge?
 

package/RELEASE_NOTES.md

@@ -1,12 +1,16 @@
-# Forge v0.10.35
+# Forge v0.10.36
 
-Released: 2026-06-03
+Released: 2026-06-04
 
-## Changes since v0.10.34
+## Changes since v0.10.35
+
+### Documentation
+- docs: README install section gets one-liner + optional deps line
 
 ### Other
-- chat: namespace gating — connector tools load on demand via connector_open
-- DocTerminal: New/Resume buttons use configured agent, not hardcoded claude
+- scripts: add install-deps.sh cross-platform installer
+- feat(chat): add 5 schedule builtin tools (create/list/delete/run/update)
+- feat(vscode-ext): add Chat + Schedules views + session switcher
 
 
-**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.10.34...v0.10.35
+**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.10.35...v0.10.36

package/lib/chat/tool-dispatcher.ts

@@ -337,6 +337,135 @@ const BUILTINS: Record<string, BuiltinHandler> = {
       : content;
   },
 
+  // ── Schedules CRUD ─────────────────────────────────────────
+  // All five direct in-process via lib/schedules/store — no HTTP, no auth.
+  // Use these instead of dispatch_task + curl: cleaner, no token shenanigans.
+
+  create_schedule: async (input) => {
+    const p = (input as any) || {};
+    const name = String(p.name || '').trim();
+    const workflow = String(p.workflow || p.body_ref || '').trim();
+    if (!name) return JSON.stringify({ ok: false, error: 'name is required' });
+    if (!workflow) return JSON.stringify({ ok: false, error: 'workflow (pipeline name) is required' });
+
+    // Trigger normalization: prefer every_minutes; accept at (once) or cron.
+    let schedule_kind: 'period' | 'once' | 'cron' = 'period';
+    let schedule_interval_minutes: number | undefined;
+    let schedule_at: string | null | undefined;
+    let schedule_cron: string | null | undefined;
+    if (p.every_minutes != null) {
+      schedule_kind = 'period';
+      schedule_interval_minutes = Number(p.every_minutes);
+    } else if (p.at) {
+      schedule_kind = 'once';
+      schedule_at = String(p.at);
+    } else if (p.cron) {
+      schedule_kind = 'cron';
+      schedule_cron = String(p.cron);
+    } else {
+      return JSON.stringify({ ok: false, error: 'one of every_minutes / at / cron is required' });
+    }
+
+    const { createSchedule, seedNextRunAt } = await import('../schedules/store');
+    try {
+      const s = createSchedule({
+        name,
+        body_kind: 'pipeline',
+        body_ref: workflow,
+        input: (p.input && typeof p.input === 'object') ? p.input : {},
+        skills: Array.isArray(p.skills) ? p.skills : undefined,
+        enabled: p.enabled !== false,
+        schedule_kind,
+        schedule_interval_minutes,
+        schedule_at: schedule_at ?? null,
+        schedule_cron: schedule_cron ?? null,
+        action_kind: p.action || 'none',
+      });
+      seedNextRunAt(s.id);
+      return JSON.stringify({
+        ok: true,
+        schedule_id: s.id,
+        name: s.name,
+        enabled: s.enabled,
+        kind: s.schedule_kind,
+        next_run_at: s.next_run_at,
+        message: `Schedule "${s.name}" created. ${schedule_kind === 'period' ? `Fires every ${schedule_interval_minutes} minutes.` : schedule_kind === 'once' ? `Fires once at ${schedule_at}.` : `Fires on cron "${schedule_cron}".`}`,
+      });
+    } catch (e: any) {
+      return JSON.stringify({ ok: false, error: e?.message || String(e) });
+    }
+  },
+
+  list_schedules: async () => {
+    const { listSchedules } = await import('../schedules/store');
+    const { decorateSchedule } = await import('../schedules/state');
+    const all = listSchedules().map(decorateSchedule);
+    return JSON.stringify({
+      schedules: all.map((s) => ({
+        id: s.id,
+        name: s.name,
+        enabled: s.enabled,
+        active_state: s.active_state,
+        schedule_kind: s.schedule_kind,
+        body_ref: s.body_ref,
+        next_run_at: s.next_run_at,
+        last_run_at: s.last_run_at,
+      })),
+      total: all.length,
+    });
+  },
+
+  delete_schedule: async (input) => {
+    const id = String((input as any)?.id || '').trim();
+    if (!id) return JSON.stringify({ ok: false, error: 'id is required' });
+    const { deleteSchedule } = await import('../schedules/store');
+    const ok = deleteSchedule(id);
+    return JSON.stringify({ ok, message: ok ? `Schedule ${id} deleted.` : `Schedule ${id} not found.` });
+  },
+
+  run_schedule_now: async (input) => {
+    const id = String((input as any)?.id || '').trim();
+    if (!id) return JSON.stringify({ ok: false, error: 'id is required' });
+    const { getSchedule } = await import('../schedules/store');
+    const s = getSchedule(id);
+    if (!s) return JSON.stringify({ ok: false, error: `Schedule ${id} not found` });
+    const { executeSchedule } = await import('../schedules/scheduler');
+    try {
+      const runId = await executeSchedule(s, 'manual');
+      return JSON.stringify({ ok: true, schedule_id: id, run_id: runId, message: `Schedule "${s.name}" fired. Run id: ${runId}.` });
+    } catch (e: any) {
+      return JSON.stringify({ ok: false, error: e?.message || String(e) });
+    }
+  },
+
+  update_schedule: async (input) => {
+    const p = (input as any) || {};
+    const id = String(p.id || '').trim();
+    if (!id) return JSON.stringify({ ok: false, error: 'id is required' });
+    const patch: Record<string, unknown> = {};
+    if (typeof p.enabled === 'boolean') patch.enabled = p.enabled;
+    if (typeof p.name === 'string') patch.name = p.name;
+    if (p.input && typeof p.input === 'object') patch.input = p.input;
+    if (Array.isArray(p.skills)) patch.skills = p.skills;
+    if (typeof p.every_minutes === 'number') {
+      patch.schedule_kind = 'period';
+      patch.schedule_interval_minutes = p.every_minutes;
+    } else if (typeof p.at === 'string') {
+      patch.schedule_kind = 'once';
+      patch.schedule_at = p.at;
+    } else if (typeof p.cron === 'string') {
+      patch.schedule_kind = 'cron';
+      patch.schedule_cron = p.cron;
+    }
+    if (Object.keys(patch).length === 0) {
+      return JSON.stringify({ ok: false, error: 'no fields to update (try enabled / name / input / skills / every_minutes / at / cron)' });
+    }
+    const { updateSchedule, seedNextRunAt } = await import('../schedules/store');
+    const ok = updateSchedule(id, patch as any);
+    if (ok && (patch.schedule_kind || patch.enabled === true)) seedNextRunAt(id);
+    return JSON.stringify({ ok, message: ok ? `Schedule ${id} updated.` : `Schedule ${id} not found.` });
+  },
+
   // Namespace gating meta-tool. Connector tools (mantis.*, gitlab.*, etc.)
   // are NOT in the active tools list by default — only their catalog entry
   // is visible in the system prompt. Calling connector_open({name}) makes
@@ -471,6 +600,66 @@ export const BUILTIN_TOOL_DEFS: BuiltinToolDef[] = [
       required: ['doc'],
     },
   },
+  {
+    name: 'create_schedule',
+    description: 'Create a recurring (or one-off) schedule that fires a Forge pipeline on a timer. NO HTTP, NO auth — runs in-process. Use this when the user says "every N minutes/hours" / "watch X" / "monitor Y" / "auto-run pipeline on schedule". REQUIRED args: name + workflow + ONE of {every_minutes, at, cron}. Returns { ok, schedule_id, next_run_at }.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'Human-readable name shown in the Schedules UI.' },
+        workflow: { type: 'string', description: 'Pipeline workflow name (file basename of flows/<name>.yaml). Run trigger_pipeline() with NO args first if unsure what names are available.' },
+        input: { type: 'object', description: 'Pipeline input fields. Same shape as trigger_pipeline.input. OMIT optional fields to use defaults.' },
+        skills: { type: 'array', items: { type: 'string' }, description: 'Skill names to inject into every Claude task this schedule spawns.' },
+        every_minutes: { type: 'number', description: 'Period in minutes (e.g. 60 = hourly). Most common trigger.' },
+        at: { type: 'string', description: 'ISO timestamp for one-shot run (e.g. "2026-06-05T09:00:00Z"). Mutually exclusive with every_minutes / cron.' },
+        cron: { type: 'string', description: 'Cron expression for complex schedules (e.g. "0 9 * * 1-5" = weekdays 9am). Mutually exclusive with every_minutes / at.' },
+        enabled: { type: 'boolean', description: 'Whether to start enabled. Default true.' },
+        action: { type: 'string', enum: ['none', 'chat', 'email', 'telegram'], description: 'Post-run notification action. Default "none".' },
+      },
+      required: ['name', 'workflow'],
+    },
+  },
+  {
+    name: 'list_schedules',
+    description: 'List all configured schedules with status (active_state: idle / running / last_failed / paused), kind, next_run_at, last_run_at. Use to find a schedule\'s id before update/delete/run.',
+    input_schema: { type: 'object', properties: {} },
+  },
+  {
+    name: 'delete_schedule',
+    description: 'Permanently delete a schedule by id. Cannot be undone. Find id via list_schedules first.',
+    input_schema: {
+      type: 'object',
+      properties: { id: { type: 'string', description: 'Schedule id from list_schedules.' } },
+      required: ['id'],
+    },
+  },
+  {
+    name: 'run_schedule_now',
+    description: 'Fire a schedule\'s configured pipeline immediately (manual trigger), regardless of when it would next fire on its timer. Returns the run_id.',
+    input_schema: {
+      type: 'object',
+      properties: { id: { type: 'string', description: 'Schedule id from list_schedules.' } },
+      required: ['id'],
+    },
+  },
+  {
+    name: 'update_schedule',
+    description: 'Patch fields on an existing schedule (enable/disable, rename, change input, swap trigger). Only the fields you pass are changed.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        id: { type: 'string', description: 'Schedule id from list_schedules.' },
+        enabled: { type: 'boolean', description: 'true to enable, false to pause without deleting.' },
+        name: { type: 'string' },
+        input: { type: 'object', description: 'New pipeline input fields (replaces existing).' },
+        skills: { type: 'array', items: { type: 'string' } },
+        every_minutes: { type: 'number', description: 'Switch trigger to interval.' },
+        at: { type: 'string', description: 'Switch trigger to one-shot at this ISO time.' },
+        cron: { type: 'string', description: 'Switch trigger to cron expression.' },
+      },
+      required: ['id'],
+    },
+  },
   {
     name: 'connector_open',
     description: 'Load a connector to make its tools (e.g. mantis.search_bugs, gitlab.list_my_todos) available for use. REQUIRED before calling any connector tool — the catalog block in the system prompt shows what each connector can do. Tools stay loaded only for the current user task; the next user message resets the open set, so re-open as needed.',

package/package.json

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