freddie 0.0.41

package/src/tools/edit.js

@@ -0,0 +1,31 @@
+import fs from 'node:fs'
+import { registry } from './registry.js'
+
+registry.register({
+    name: 'edit',
+    toolset: 'core',
+    schema: {
+        name: 'edit',
+        description: 'Replace exact string in file. Fails if old_string occurs zero or multiple times unless replace_all.',
+        parameters: {
+            type: 'object',
+            properties: {
+                path: { type: 'string' },
+                old_string: { type: 'string' },
+                new_string: { type: 'string' },
+                replace_all: { type: 'boolean', default: false },
+            },
+            required: ['path', 'old_string', 'new_string'],
+        },
+    },
+    handler: async ({ path: p, old_string, new_string, replace_all = false }) => {
+        if (!fs.existsSync(p)) return { error: `not found: ${p}` }
+        const src = fs.readFileSync(p, 'utf8')
+        const occurrences = src.split(old_string).length - 1
+        if (occurrences === 0) return { error: 'old_string not found' }
+        if (occurrences > 1 && !replace_all) return { error: `old_string matches ${occurrences} times; pass replace_all=true` }
+        const out = replace_all ? src.split(old_string).join(new_string) : src.replace(old_string, new_string)
+        fs.writeFileSync(p, out, 'utf8')
+        return { path: p, replacements: replace_all ? occurrences : 1 }
+    },
+})

package/src/tools/env_passthrough.js

@@ -0,0 +1,15 @@
+import { registry } from './registry.js'
+import { getConfigValue } from '../config.js'
+
+export function buildBashEnv() {
+    const allow = getConfigValue('terminal.env_passthrough', ['HOME', 'USER', 'LANG', 'PATH', 'SHELL']) || []
+    const out = {}
+    for (const k of allow) if (process.env[k]) out[k] = process.env[k]
+    return out
+}
+registry.register({
+    name: 'env_passthrough',
+    toolset: 'core',
+    schema: { name: 'env_passthrough', description: 'Compute the env-var subset that should be passed through to spawned shells.', parameters: { type: 'object', properties: {} } },
+    handler: async () => ({ env: buildBashEnv() }),
+})

package/src/tools/environments/base.js

@@ -0,0 +1,26 @@
+export class BaseEnvironment {
+    constructor(opts = {}) { this.opts = opts; this.cwd = opts.cwd || '/workspace'; this.name = 'base' }
+    async run(_cmd, _o) { throw new Error(this.name + '.run() not implemented') }
+    async put(_l, _r) { throw new Error(this.name + '.put() not implemented') }
+    async get(_r, _l) { throw new Error(this.name + '.get() not implemented') }
+    async shutdown() {}
+    async ready() { return true }
+}
+
+export async function fetchJson(url, { method = 'GET', headers = {}, body, timeoutMs = 60000 } = {}) {
+    const ctrl = new AbortController()
+    const t = setTimeout(() => ctrl.abort(), timeoutMs)
+    try {
+        const res = await fetch(url, { method, headers: { 'content-type': 'application/json', ...headers }, body: body ? JSON.stringify(body) : undefined, signal: ctrl.signal })
+        const txt = await res.text()
+        let json = null
+        try { json = txt ? JSON.parse(txt) : null } catch { json = { raw: txt } }
+        return { ok: res.ok, status: res.status, json, text: txt }
+    } finally { clearTimeout(t) }
+}
+
+export function requireEnv(name) {
+    const v = process.env[name]
+    if (!v) throw new Error('missing env: ' + name)
+    return v
+}

package/src/tools/environments/daytona.js

@@ -0,0 +1,48 @@
+import { BaseEnvironment, fetchJson, requireEnv } from './base.js'
+
+export class DaytonaEnvironment extends BaseEnvironment {
+    constructor(opts = {}) {
+        super(opts)
+        this.name = 'daytona'
+        this.apiUrl = opts.apiUrl || process.env.DAYTONA_API_URL || 'https://app.daytona.io/api'
+        this.apiKey = opts.apiKey || process.env.DAYTONA_API_KEY
+        this.target = opts.target || process.env.DAYTONA_TARGET || 'us'
+        this.workspaceId = opts.workspaceId || null
+        this.cwd = opts.cwd || '/workspace'
+    }
+    headers() { return { authorization: 'Bearer ' + (this.apiKey || requireEnv('DAYTONA_API_KEY')) } }
+    async ensureWorkspace() {
+        if (this.workspaceId) return this.workspaceId
+        const r = await fetchJson(this.apiUrl + '/workspace', { method: 'POST', headers: this.headers(), body: { target: this.target, image: this.opts.image || 'ubuntu:22.04' } })
+        if (!r.ok) throw new Error('daytona create: ' + r.status + ' ' + r.text)
+        this.workspaceId = r.json.id
+        return this.workspaceId
+    }
+    async run(cmd, { timeoutMs = 120000 } = {}) {
+        try {
+            const id = await this.ensureWorkspace()
+            const r = await fetchJson(this.apiUrl + '/workspace/' + id + '/exec', { method: 'POST', headers: this.headers(), body: { command: cmd, cwd: this.cwd }, timeoutMs })
+            return { exitCode: r.json?.exit_code ?? (r.ok ? 0 : -1), stdout: r.json?.stdout || '', stderr: r.json?.stderr || (!r.ok ? r.text : '') }
+        } catch (e) { return { exitCode: -1, stdout: '', stderr: e.message } }
+    }
+    async put(localPath, remotePath) {
+        const fs = await import('node:fs')
+        const id = await this.ensureWorkspace()
+        const buf = fs.readFileSync(localPath)
+        const r = await fetchJson(this.apiUrl + '/workspace/' + id + '/files', { method: 'POST', headers: this.headers(), body: { path: remotePath, content: buf.toString('base64'), encoding: 'base64' } })
+        return { copied: remotePath, ok: r.ok }
+    }
+    async get(remotePath, localPath) {
+        const fs = await import('node:fs')
+        const id = await this.ensureWorkspace()
+        const r = await fetchJson(this.apiUrl + '/workspace/' + id + '/files?path=' + encodeURIComponent(remotePath), { headers: this.headers() })
+        if (!r.ok) return { error: r.text }
+        fs.writeFileSync(localPath, Buffer.from(r.json?.content || '', 'base64'))
+        return { copied: localPath }
+    }
+    async shutdown() {
+        if (!this.workspaceId) return
+        await fetchJson(this.apiUrl + '/workspace/' + this.workspaceId, { method: 'DELETE', headers: this.headers() })
+        this.workspaceId = null
+    }
+}

package/src/tools/environments/docker.js

@@ -0,0 +1,14 @@
+export class DockerEnvironment {
+    constructor(opts = {}) { this.image = opts.image || 'ubuntu:latest'; this.name = 'docker' }
+    async run(_cmd) { throw new Error('DockerEnvironment: install dockerode and replace this method') }
+    async put() { throw new Error('DockerEnvironment: install dockerode') }
+    async get() { throw new Error('DockerEnvironment: install dockerode') }
+    async shutdown() {}
+}
+
+let _dockerodeAvailable = null
+export async function probeDockerode() {
+    if (_dockerodeAvailable !== null) return _dockerodeAvailable
+    try { await import('dockerode'); _dockerodeAvailable = true } catch { _dockerodeAvailable = false }
+    return _dockerodeAvailable
+}

package/src/tools/environments/file_sync.js

@@ -0,0 +1,60 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import crypto from 'node:crypto'
+
+function sha256(buf) { return crypto.createHash('sha256').update(buf).digest('hex') }
+
+function walk(root) {
+    const out = []
+    function rec(dir, rel) {
+        for (const ent of fs.readdirSync(dir, { withFileTypes: true })) {
+            const abs = path.join(dir, ent.name)
+            const r = path.posix.join(rel, ent.name)
+            if (ent.isDirectory()) {
+                if (ent.name === '.git' || ent.name === 'node_modules') continue
+                rec(abs, r)
+            } else if (ent.isFile()) {
+                const buf = fs.readFileSync(abs)
+                out.push({ rel: r, abs, hash: sha256(buf), size: buf.length })
+            }
+        }
+    }
+    rec(root, '')
+    return out
+}
+
+export async function syncTo(env, localRoot, remoteRoot, { onProgress } = {}) {
+    const files = walk(localRoot)
+    let transferred = 0
+    for (const f of files) {
+        const target = path.posix.join(remoteRoot, f.rel)
+        const r = await env.put(f.abs, target)
+        transferred++
+        if (onProgress) onProgress({ rel: f.rel, transferred, total: files.length, status: r.error ? 'error' : 'ok', error: r.error })
+    }
+    return { files: files.length, transferred }
+}
+
+export async function syncFrom(env, remoteRoot, localRoot, manifest = []) {
+    fs.mkdirSync(localRoot, { recursive: true })
+    let transferred = 0
+    for (const rel of manifest) {
+        const remote = path.posix.join(remoteRoot, rel)
+        const local = path.join(localRoot, rel)
+        fs.mkdirSync(path.dirname(local), { recursive: true })
+        const r = await env.get(remote, local)
+        if (!r.error) transferred++
+    }
+    return { transferred, total: manifest.length }
+}
+
+export function diffManifest(localRoot, remoteManifest = []) {
+    const local = walk(localRoot)
+    const localByRel = new Map(local.map(f => [f.rel, f]))
+    const remoteByRel = new Map(remoteManifest.map(f => [f.rel, f]))
+    const toUpload = local.filter(f => remoteByRel.get(f.rel)?.hash !== f.hash).map(f => f.rel)
+    const toDelete = remoteManifest.filter(f => !localByRel.has(f.rel)).map(f => f.rel)
+    return { toUpload, toDelete }
+}
+
+export { walk, sha256 }

package/src/tools/environments/index.js

@@ -0,0 +1,36 @@
+import { LocalEnvironment } from './local.js'
+import { DockerEnvironment } from './docker.js'
+import { SshEnvironment } from './ssh.js'
+import { ModalEnvironment, ManagedModalEnvironment } from './modal.js'
+import { DaytonaEnvironment } from './daytona.js'
+import { SingularityEnvironment } from './singularity.js'
+import { VercelSandboxEnvironment } from './vercel_sandbox.js'
+import { BaseEnvironment } from './base.js'
+import { syncTo, syncFrom, diffManifest } from './file_sync.js'
+import { getConfigValue } from '../../config.js'
+
+const FACTORIES = {
+    local: (opts) => new LocalEnvironment(opts),
+    docker: (opts) => new DockerEnvironment(opts),
+    ssh: (opts) => new SshEnvironment(opts),
+    modal: (opts) => new ModalEnvironment(opts),
+    managed_modal: (opts) => new ManagedModalEnvironment(opts),
+    daytona: (opts) => new DaytonaEnvironment(opts),
+    singularity: (opts) => new SingularityEnvironment(opts),
+    vercel_sandbox: (opts) => new VercelSandboxEnvironment(opts),
+}
+
+export function listEnvironments() { return Object.keys(FACTORIES) }
+
+export function createEnvironment(name, opts = {}) {
+    const f = FACTORIES[name]
+    if (!f) throw new Error('unknown environment: ' + name + ' (available: ' + Object.keys(FACTORIES).join(', ') + ')')
+    return f(opts)
+}
+
+export function defaultEnvironment(opts = {}) {
+    const name = getConfigValue('terminal.environment', 'local')
+    return createEnvironment(name, opts)
+}
+
+export { LocalEnvironment, DockerEnvironment, SshEnvironment, ModalEnvironment, ManagedModalEnvironment, DaytonaEnvironment, SingularityEnvironment, VercelSandboxEnvironment, BaseEnvironment, syncTo, syncFrom, diffManifest }

package/src/tools/environments/local.js

@@ -0,0 +1,31 @@
+import { spawn } from 'node:child_process'
+import fs from 'node:fs'
+import path from 'node:path'
+
+export class LocalEnvironment {
+    constructor(opts = {}) { this.cwd = opts.cwd || process.cwd(); this.name = 'local' }
+    async run(cmd, { timeoutMs = 60000 } = {}) {
+        return new Promise(resolve => {
+            const sh = process.platform === 'win32' ? 'cmd' : 'sh'
+            const flag = process.platform === 'win32' ? '/c' : '-c'
+            const child = spawn(sh, [flag, cmd], { cwd: this.cwd, env: process.env })
+            let stdout = '', stderr = ''
+            const t = setTimeout(() => { try { child.kill('SIGKILL') } catch {} resolve({ exitCode: -1, stdout, stderr: stderr + '\n[timeout]' }) }, timeoutMs)
+            child.stdout?.on('data', d => stdout += d.toString())
+            child.stderr?.on('data', d => stderr += d.toString())
+            child.on('close', code => { clearTimeout(t); resolve({ exitCode: code, stdout, stderr }) })
+            child.on('error', e => { clearTimeout(t); resolve({ exitCode: -1, stdout, stderr: stderr + '\n' + e.message }) })
+        })
+    }
+    async put(localPath, remotePath) {
+        fs.mkdirSync(path.dirname(remotePath), { recursive: true })
+        fs.copyFileSync(localPath, remotePath)
+        return { copied: remotePath }
+    }
+    async get(remotePath, localPath) {
+        fs.mkdirSync(path.dirname(localPath), { recursive: true })
+        fs.copyFileSync(remotePath, localPath)
+        return { copied: localPath }
+    }
+    async shutdown() {}
+}

package/src/tools/environments/modal.js

@@ -0,0 +1,33 @@
+import { spawn } from 'node:child_process'
+import { BaseEnvironment } from './base.js'
+
+export class ModalEnvironment extends BaseEnvironment {
+    constructor(opts = {}) {
+        super(opts)
+        this.name = 'modal'
+        this.app = opts.app || 'freddie-sandbox'
+        this.image = opts.image || 'python:3.11'
+        this.cwd = opts.cwd || '/sandbox'
+        this.token = process.env.MODAL_TOKEN_ID
+        this.secret = process.env.MODAL_TOKEN_SECRET
+    }
+    async run(cmd, { timeoutMs = 120000 } = {}) {
+        if (!this.token) return { exitCode: -1, stdout: '', stderr: 'MODAL_TOKEN_ID required' }
+        return new Promise(resolve => {
+            const env = { ...process.env, MODAL_TOKEN_ID: this.token, MODAL_TOKEN_SECRET: this.secret }
+            const child = spawn('modal', ['run', '--detach=false', '-q', '-', cmd], { env, shell: process.platform === 'win32' })
+            let stdout = '', stderr = ''
+            const t = setTimeout(() => { try { child.kill('SIGKILL') } catch {} resolve({ exitCode: -1, stdout, stderr: stderr + '\n[timeout]' }) }, timeoutMs)
+            child.stdout?.on('data', d => stdout += d.toString())
+            child.stderr?.on('data', d => stderr += d.toString())
+            child.on('close', code => { clearTimeout(t); resolve({ exitCode: code, stdout, stderr }) })
+            child.on('error', e => { clearTimeout(t); resolve({ exitCode: -1, stdout, stderr: stderr + '\n' + e.message }) })
+        })
+    }
+    async put(localPath, remotePath) { return { error: 'modal put requires modal volume put: ' + localPath + ' -> ' + remotePath } }
+    async get(remotePath, localPath) { return { error: 'modal get requires modal volume get: ' + remotePath + ' -> ' + localPath } }
+}
+
+export class ManagedModalEnvironment extends ModalEnvironment {
+    constructor(opts = {}) { super({ ...opts, app: opts.app || 'freddie-managed' }); this.name = 'managed_modal' }
+}

package/src/tools/environments/singularity.js

@@ -0,0 +1,38 @@
+import { spawn } from 'node:child_process'
+import { BaseEnvironment } from './base.js'
+
+export class SingularityEnvironment extends BaseEnvironment {
+    constructor(opts = {}) {
+        super(opts)
+        this.name = 'singularity'
+        this.image = opts.image || 'docker://ubuntu:22.04'
+        this.binary = opts.binary || process.env.SINGULARITY_BIN || 'singularity'
+        this.binds = opts.binds || []
+        this.cwd = opts.cwd || '/workspace'
+    }
+    _bindArgs() {
+        const args = []
+        for (const b of this.binds) args.push('--bind', b)
+        return args
+    }
+    async run(cmd, { timeoutMs = 120000 } = {}) {
+        return new Promise(resolve => {
+            const args = ['exec', '--pwd', this.cwd, ...this._bindArgs(), this.image, 'sh', '-c', cmd]
+            const child = spawn(this.binary, args, { env: process.env })
+            let stdout = '', stderr = ''
+            const t = setTimeout(() => { try { child.kill('SIGKILL') } catch {} resolve({ exitCode: -1, stdout, stderr: stderr + '\n[timeout]' }) }, timeoutMs)
+            child.stdout?.on('data', d => stdout += d.toString())
+            child.stderr?.on('data', d => stderr += d.toString())
+            child.on('close', code => { clearTimeout(t); resolve({ exitCode: code, stdout, stderr }) })
+            child.on('error', e => { clearTimeout(t); resolve({ exitCode: -1, stdout, stderr: stderr + '\n' + e.message }) })
+        })
+    }
+    async put(localPath, remotePath) {
+        const r = await this.run('mkdir -p "$(dirname \'' + remotePath + '\')" && cp "' + localPath + '" "' + remotePath + '"')
+        return r.exitCode === 0 ? { copied: remotePath } : { error: r.stderr }
+    }
+    async get(remotePath, localPath) {
+        const r = await this.run('cp "' + remotePath + '" "' + localPath + '"')
+        return r.exitCode === 0 ? { copied: localPath } : { error: r.stderr }
+    }
+}

package/src/tools/environments/ssh.js

@@ -0,0 +1,14 @@
+export class SshEnvironment {
+    constructor(opts = {}) { this.host = opts.host; this.user = opts.user; this.name = 'ssh' }
+    async run(_cmd) { throw new Error('SshEnvironment: install ssh2 and replace this method') }
+    async put() { throw new Error('SshEnvironment: install ssh2') }
+    async get() { throw new Error('SshEnvironment: install ssh2') }
+    async shutdown() {}
+}
+
+let _ssh2Available = null
+export async function probeSsh2() {
+    if (_ssh2Available !== null) return _ssh2Available
+    try { await import('ssh2'); _ssh2Available = true } catch { _ssh2Available = false }
+    return _ssh2Available
+}

package/src/tools/environments/vercel_sandbox.js

@@ -0,0 +1,47 @@
+import { BaseEnvironment, fetchJson, requireEnv } from './base.js'
+
+export class VercelSandboxEnvironment extends BaseEnvironment {
+    constructor(opts = {}) {
+        super(opts)
+        this.name = 'vercel_sandbox'
+        this.apiUrl = opts.apiUrl || process.env.VERCEL_SANDBOX_URL || 'https://api.vercel.com/v1/sandbox'
+        this.token = opts.token || process.env.VERCEL_TOKEN
+        this.runtime = opts.runtime || 'node22'
+        this.sandboxId = null
+        this.cwd = opts.cwd || '/vercel/sandbox'
+    }
+    headers() { return { authorization: 'Bearer ' + (this.token || requireEnv('VERCEL_TOKEN')) } }
+    async ensureSandbox() {
+        if (this.sandboxId) return this.sandboxId
+        const r = await fetchJson(this.apiUrl, { method: 'POST', headers: this.headers(), body: { runtime: this.runtime, timeout: this.opts.timeoutSec || 600 } })
+        if (!r.ok) throw new Error('vercel sandbox create: ' + r.status + ' ' + r.text)
+        this.sandboxId = r.json.id
+        return this.sandboxId
+    }
+    async run(cmd, { timeoutMs = 120000 } = {}) {
+        try {
+            const id = await this.ensureSandbox()
+            const r = await fetchJson(this.apiUrl + '/' + id + '/exec', { method: 'POST', headers: this.headers(), body: { cmd: ['sh', '-c', cmd], cwd: this.cwd }, timeoutMs })
+            return { exitCode: r.json?.exitCode ?? (r.ok ? 0 : -1), stdout: r.json?.stdout || '', stderr: r.json?.stderr || (!r.ok ? r.text : '') }
+        } catch (e) { return { exitCode: -1, stdout: '', stderr: e.message } }
+    }
+    async put(localPath, remotePath) {
+        const fs = await import('node:fs')
+        const id = await this.ensureSandbox()
+        const r = await fetchJson(this.apiUrl + '/' + id + '/files', { method: 'PUT', headers: this.headers(), body: { path: remotePath, content: fs.readFileSync(localPath).toString('base64'), encoding: 'base64' } })
+        return r.ok ? { copied: remotePath } : { error: r.text }
+    }
+    async get(remotePath, localPath) {
+        const fs = await import('node:fs')
+        const id = await this.ensureSandbox()
+        const r = await fetchJson(this.apiUrl + '/' + id + '/files?path=' + encodeURIComponent(remotePath), { headers: this.headers() })
+        if (!r.ok) return { error: r.text }
+        fs.writeFileSync(localPath, Buffer.from(r.json?.content || '', 'base64'))
+        return { copied: localPath }
+    }
+    async shutdown() {
+        if (!this.sandboxId) return
+        await fetchJson(this.apiUrl + '/' + this.sandboxId, { method: 'DELETE', headers: this.headers() })
+        this.sandboxId = null
+    }
+}

package/src/tools/feishu_doc.js

@@ -0,0 +1,15 @@
+import { registry } from './registry.js'
+registry.register({
+    name: 'feishu_doc',
+    toolset: 'core',
+    schema: { name: 'feishu_doc', description: 'Read or update a Feishu doc by token.', parameters: { type: 'object', properties: { action: { type: 'string', enum: ['get', 'patch'] }, doc_token: { type: 'string' }, content: {} }, required: ['action', 'doc_token'] } },
+    requiresEnv: ['FEISHU_APP_TOKEN'],
+    checkFn: () => Boolean(process.env.FEISHU_APP_TOKEN),
+    handler: async ({ action, doc_token, content }) => {
+        const auth = { authorization: `Bearer ${process.env.FEISHU_APP_TOKEN}` }
+        const base = 'https://open.feishu.cn/open-apis/docx/v1/documents/' + doc_token
+        if (action === 'get') return await (await fetch(base, { headers: auth })).json()
+        if (action === 'patch') return await (await fetch(base + '/blocks', { method: 'PATCH', headers: { ...auth, 'content-type': 'application/json' }, body: JSON.stringify(content) })).json()
+        return { error: 'unknown action' }
+    },
+})

package/src/tools/feishu_drive.js

@@ -0,0 +1,14 @@
+import { registry } from './registry.js'
+registry.register({
+    name: 'feishu_drive',
+    toolset: 'core',
+    schema: { name: 'feishu_drive', description: 'List or download Feishu Drive files.', parameters: { type: 'object', properties: { action: { type: 'string', enum: ['list', 'download'] }, folder_token: { type: 'string' }, file_token: { type: 'string' } }, required: ['action'] } },
+    requiresEnv: ['FEISHU_APP_TOKEN'],
+    checkFn: () => Boolean(process.env.FEISHU_APP_TOKEN),
+    handler: async ({ action, folder_token, file_token }) => {
+        const auth = { authorization: `Bearer ${process.env.FEISHU_APP_TOKEN}` }
+        if (action === 'list') return await (await fetch('https://open.feishu.cn/open-apis/drive/v1/files?folder_token=' + (folder_token || ''), { headers: auth })).json()
+        if (action === 'download') return await (await fetch(`https://open.feishu.cn/open-apis/drive/v1/files/${file_token}/download`, { headers: auth })).json()
+        return { error: 'unknown action' }
+    },
+})

package/src/tools/file_operations.js

@@ -0,0 +1,17 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { registry } from './registry.js'
+
+const ACTIONS = {
+    move: ({ src, dest }) => { fs.mkdirSync(path.dirname(dest), { recursive: true }); fs.renameSync(src, dest); return { moved: dest } },
+    copy: ({ src, dest }) => { fs.mkdirSync(path.dirname(dest), { recursive: true }); fs.copyFileSync(src, dest); return { copied: dest } },
+    delete: ({ path: p }) => { if (fs.existsSync(p)) fs.rmSync(p, { recursive: true, force: true }); return { deleted: p } },
+    mkdir: ({ path: p }) => { fs.mkdirSync(p, { recursive: true }); return { created: p } },
+    stat: ({ path: p }) => { const s = fs.statSync(p); return { size: s.size, mtime: s.mtimeMs, isDir: s.isDirectory() } },
+}
+registry.register({
+    name: 'file_operations',
+    toolset: 'core',
+    schema: { name: 'file_operations', description: 'move/copy/delete/mkdir/stat — atomic file ops.', parameters: { type: 'object', properties: { action: { type: 'string', enum: Object.keys(ACTIONS) }, src: { type: 'string' }, dest: { type: 'string' }, path: { type: 'string' } }, required: ['action'] } },
+    handler: async (a) => { const fn = ACTIONS[a.action]; try { return fn ? fn(a) : { error: 'unknown action' } } catch (e) { return { error: String(e.message || e) } } },
+})

package/src/tools/file_state.js

@@ -0,0 +1,16 @@
+import { db } from '../db.js'
+import { registry } from './registry.js'
+
+async function init() { const d = await db(); d.exec(`CREATE TABLE IF NOT EXISTS file_state (id INTEGER PRIMARY KEY AUTOINCREMENT, session_id TEXT, file_path TEXT NOT NULL, action TEXT NOT NULL, ts INTEGER NOT NULL)`); return d }
+registry.register({
+    name: 'file_state',
+    toolset: 'core',
+    schema: { name: 'file_state', description: 'Track files modified in this session (read|write|edit|delete) for diff-summary purposes.', parameters: { type: 'object', properties: { action: { type: 'string', enum: ['record', 'list', 'changed_in_session'] }, session_id: { type: 'string' }, file_path: { type: 'string' }, op: { type: 'string' } }, required: ['action'] } },
+    handler: async ({ action, session_id, file_path, op }) => {
+        const d = await init()
+        if (action === 'record') { d.prepare('INSERT INTO file_state (session_id, file_path, action, ts) VALUES (?, ?, ?, ?)').run(session_id, file_path, op, Date.now()); return { recorded: true } }
+        if (action === 'list') return { items: d.prepare('SELECT * FROM file_state WHERE session_id = ? ORDER BY id DESC').all(session_id) }
+        if (action === 'changed_in_session') return { files: [...new Set(d.prepare('SELECT file_path FROM file_state WHERE session_id = ?').all(session_id).map(r => r.file_path))] }
+        return { error: 'unknown action' }
+    },
+})

package/src/tools/file_tools.js

@@ -0,0 +1,23 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { registry } from './registry.js'
+
+function walk(dir, out, skip) {
+    let entries; try { entries = fs.readdirSync(dir, { withFileTypes: true }) } catch { return }
+    for (const e of entries) {
+        if (skip.has(e.name)) continue
+        const full = path.join(dir, e.name)
+        if (e.isDirectory()) walk(full, out, skip)
+        else out.push(full)
+    }
+}
+registry.register({
+    name: 'file_tools',
+    toolset: 'core',
+    schema: { name: 'file_tools', description: 'list/glob files (recursive walk skipping node_modules, .git, dist).', parameters: { type: 'object', properties: { dir: { type: 'string', default: '.' }, ext: { type: 'string' }, limit: { type: 'number', default: 1000 } } } },
+    handler: async ({ dir = '.', ext, limit = 1000 }) => {
+        const out = []; walk(dir, out, new Set(['node_modules', '.git', 'dist', '.cache', 'build']))
+        const filtered = ext ? out.filter(f => f.endsWith(ext)) : out
+        return { files: filtered.slice(0, limit), total: filtered.length, truncated: filtered.length > limit }
+    },
+})

package/src/tools/fuzzy_match.js

@@ -0,0 +1,8 @@
+import { fuzzyMatch as helper } from '../utils.js'
+import { registry } from './registry.js'
+registry.register({
+    name: 'fuzzy_match',
+    toolset: 'core',
+    schema: { name: 'fuzzy_match', description: 'Score a candidate string against a needle. Returns 0 for no match, higher for better match.', parameters: { type: 'object', properties: { needle: { type: 'string' }, haystack: { type: 'string' } }, required: ['needle', 'haystack'] } },
+    handler: async ({ needle, haystack }) => ({ score: helper(needle, haystack) }),
+})

package/src/tools/grep.js

@@ -0,0 +1,51 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { registry } from './registry.js'
+
+registry.register({
+    name: 'grep',
+    toolset: 'core',
+    schema: {
+        name: 'grep',
+        description: 'Recursive regex search across files. Returns file:line:content matches.',
+        parameters: {
+            type: 'object',
+            properties: {
+                pattern: { type: 'string' },
+                path: { type: 'string', default: '.' },
+                glob: { type: 'string' },
+                head_limit: { type: 'number', default: 200 },
+                ignore_case: { type: 'boolean', default: false },
+            },
+            required: ['pattern'],
+        },
+    },
+    handler: async ({ pattern, path: root = '.', head_limit = 200, ignore_case = false, glob }) => {
+        const re = new RegExp(pattern, ignore_case ? 'i' : '')
+        const out = []
+        const skipDirs = new Set(['node_modules', '.git', 'dist', 'build', '.cache'])
+        const walk = (d) => {
+            if (out.length >= head_limit) return
+            let entries
+            try { entries = fs.readdirSync(d, { withFileTypes: true }) } catch { return }
+            for (const e of entries) {
+                if (out.length >= head_limit) return
+                const full = path.join(d, e.name)
+                if (e.isDirectory()) { if (!skipDirs.has(e.name)) walk(full); continue }
+                if (glob && !matchGlob(e.name, glob)) continue
+                let content
+                try { content = fs.readFileSync(full, 'utf8') } catch { continue }
+                content.split('\n').forEach((line, i) => {
+                    if (out.length < head_limit && re.test(line)) out.push(`${full}:${i + 1}:${line.slice(0, 200)}`)
+                })
+            }
+        }
+        walk(root)
+        return { matches: out, total: out.length, truncated: out.length >= head_limit }
+    },
+})
+
+function matchGlob(name, glob) {
+    const re = new RegExp('^' + glob.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*').replace(/\?/g, '.') + '$', 'i')
+    return re.test(name)
+}

package/src/tools/homeassistant_tool.js

@@ -0,0 +1,15 @@
+import { registry } from './registry.js'
+registry.register({
+    name: 'homeassistant_tool',
+    toolset: 'core',
+    schema: { name: 'homeassistant_tool', description: 'Read state or call a service on Home Assistant.', parameters: { type: 'object', properties: { action: { type: 'string', enum: ['state', 'service'] }, entity_id: { type: 'string' }, domain: { type: 'string' }, service: { type: 'string' }, data: {} }, required: ['action'] } },
+    requiresEnv: ['HASS_TOKEN', 'HASS_URL'],
+    checkFn: () => Boolean(process.env.HASS_TOKEN),
+    handler: async ({ action, entity_id, domain, service, data = {} }) => {
+        const url = process.env.HASS_URL || 'http://homeassistant.local:8123'
+        const auth = { authorization: `Bearer ${process.env.HASS_TOKEN}` }
+        if (action === 'state') return await (await fetch(`${url}/api/states/${entity_id}`, { headers: auth })).json()
+        if (action === 'service') return await (await fetch(`${url}/api/services/${domain}/${service}`, { method: 'POST', headers: { ...auth, 'content-type': 'application/json' }, body: JSON.stringify({ entity_id, ...data }) })).json()
+        return { error: 'unknown action' }
+    },
+})

package/src/tools/image_gen.js

@@ -0,0 +1,33 @@
+import { registry } from './registry.js'
+
+registry.register({
+    name: 'image_gen',
+    toolset: 'creative',
+    schema: {
+        name: 'image_gen',
+        description: 'Generate an image from a prompt. Provider via config.image_gen.provider (openai|replicate).',
+        parameters: {
+            type: 'object',
+            properties: {
+                prompt: { type: 'string' },
+                provider: { type: 'string', enum: ['openai', 'replicate'] },
+                size: { type: 'string', default: '1024x1024' },
+                model: { type: 'string' },
+            },
+            required: ['prompt'],
+        },
+    },
+    checkFn: () => Boolean(process.env.OPENAI_API_KEY || process.env.REPLICATE_API_TOKEN),
+    requiresEnv: ['OPENAI_API_KEY or REPLICATE_API_TOKEN'],
+    handler: async ({ prompt, provider, size = '1024x1024', model }) => {
+        const which = provider || (process.env.OPENAI_API_KEY ? 'openai' : 'replicate')
+        if (which === 'openai') {
+            if (!process.env.OPENAI_API_KEY) return { error: 'OPENAI_API_KEY required' }
+            const res = await fetch('https://api.openai.com/v1/images/generations', { method: 'POST', headers: { authorization: `Bearer ${process.env.OPENAI_API_KEY}`, 'content-type': 'application/json' }, body: JSON.stringify({ model: model || 'gpt-image-1', prompt, size }) })
+            return await res.json()
+        }
+        if (!process.env.REPLICATE_API_TOKEN) return { error: 'REPLICATE_API_TOKEN required' }
+        const res = await fetch('https://api.replicate.com/v1/predictions', { method: 'POST', headers: { authorization: `Token ${process.env.REPLICATE_API_TOKEN}`, 'content-type': 'application/json' }, body: JSON.stringify({ version: model || 'black-forest-labs/flux-schnell', input: { prompt } }) })
+        return await res.json()
+    },
+})

package/src/tools/interrupt.js

@@ -0,0 +1,18 @@
+import { registry } from './registry.js'
+
+const _flags = new Map()
+export function setInterrupt(sessionId) { _flags.set(sessionId, true) }
+export function isInterrupted(sessionId) { return _flags.get(sessionId) === true }
+export function clearInterrupt(sessionId) { _flags.delete(sessionId) }
+
+registry.register({
+    name: 'interrupt',
+    toolset: 'core',
+    schema: { name: 'interrupt', description: 'Set/clear/check interrupt flag for a session — agent loop polls and exits early.', parameters: { type: 'object', properties: { action: { type: 'string', enum: ['set', 'clear', 'check'] }, session_id: { type: 'string' } }, required: ['action', 'session_id'] } },
+    handler: async ({ action, session_id }) => {
+        if (action === 'set') { setInterrupt(session_id); return { interrupted: true } }
+        if (action === 'clear') { clearInterrupt(session_id); return { cleared: true } }
+        if (action === 'check') return { interrupted: isInterrupted(session_id) }
+        return { error: 'unknown action' }
+    },
+})