freddie 0.0.41

package/src/cli/completion.js

@@ -0,0 +1,21 @@
+import { COMMAND_REGISTRY } from '../commands/registry.js'
+import { listSkills } from '../skills/index.js'
+export function completeSlash(prefix) {
+    const p = prefix.replace(/^\//, '').toLowerCase()
+    const out = new Set()
+    for (const c of COMMAND_REGISTRY) {
+        if (c.name.startsWith(p)) out.add('/' + c.name)
+        for (const a of c.aliases) if (a.startsWith(p)) out.add('/' + a)
+    }
+    return [...out].sort()
+}
+export function completeSkill(prefix) {
+    const p = String(prefix).toLowerCase()
+    return listSkills().filter(s => s.name.toLowerCase().startsWith(p)).map(s => s.name).sort()
+}
+export function complete(line) {
+    if (line.startsWith('/')) return completeSlash(line)
+    const m = line.match(/@skill\/([\w-]*)$/)
+    if (m) return completeSkill(m[1]).map(s => '@skill/' + s)
+    return []
+}

package/src/cli/copilot_auth.js

@@ -0,0 +1,9 @@
+import { getAuthStore } from '../auth.js'
+const KEY = 'COPILOT_TOKEN'
+export async function getCopilotToken() {
+    if (process.env.COPILOT_TOKEN) return { source: 'env', value: process.env.COPILOT_TOKEN }
+    const stored = await getAuthStore().getCredential(KEY)
+    return stored?.value ? { source: 'auth-store', value: stored.value } : { source: 'none', value: null }
+}
+export async function setCopilotToken(token) { return await getAuthStore().setCredential(KEY, token) }
+export async function clearCopilotToken() { return await getAuthStore().deleteCredential(KEY) }

package/src/cli/curator_cli.js

@@ -0,0 +1,5 @@
+import { add, list, clear } from '../agent/curator.js'
+export const CURATOR_KINDS = ['favourite-prompt', 'pinned-session', 'shortcut', 'snippet']
+export function curatorAdd(kind, key, value) { return add(kind, key, value) }
+export function curatorList(kind) { return list(kind) }
+export function curatorClear(kind) { return clear(kind) }

package/src/cli/curses.js

@@ -0,0 +1,15 @@
+let _blessed = null
+async function probe() { if (_blessed !== null) return _blessed; try { _blessed = await import('blessed') } catch { _blessed = false } return _blessed }
+
+export async function launchCurses({ output } = {}) {
+    const b = await probe()
+    if (!b) return { error: 'blessed not installed; run: npm install blessed' }
+    const blessed = b.default || b
+    const screen = blessed.screen({ smartCSR: true, title: 'freddie' })
+    const log = blessed.log({ top: 0, left: 0, width: '100%', height: '90%', scrollable: true, alwaysScroll: true })
+    const input = blessed.textbox({ bottom: 0, left: 0, width: '100%', height: 3, inputOnFocus: true })
+    screen.append(log); screen.append(input)
+    screen.key(['C-c', 'q'], () => process.exit(0))
+    screen.render()
+    return { screen, log, input, render: () => screen.render(), close: () => screen.destroy() }
+}

package/src/cli/debug.js

@@ -0,0 +1,6 @@
+import { listDebug, snapshot, snapshotAll } from '../observability/debug.js'
+let _verbose = Boolean(process.env.FREDDIE_DEBUG)
+export function isVerbose() { return _verbose }
+export function setVerbose(v) { _verbose = Boolean(v); process.env.FREDDIE_DEBUG = v ? '1' : '' }
+export function dprint(...args) { if (_verbose) console.error('[debug]', ...args) }
+export function dumpDebug(name) { return name ? snapshot(name) : { subsystems: listDebug(), all: snapshotAll() } }

package/src/cli/default_soul.js

@@ -0,0 +1,20 @@
+import { getActiveSkin, setActiveSkin } from '../skin/engine.js'
+import { saveConfigValue } from '../config.js'
+export const SOULS = {
+    classic: { skin: 'default', persona: 'You are Freddie, a thoughtful collaborator.' },
+    ares: { skin: 'ares', persona: 'You are Ares: direct, forceful, action-oriented.' },
+    mono: { skin: 'mono', persona: 'You are a minimal monochrome assistant.' },
+    slate: { skin: 'slate', persona: 'You are a calm, precise developer assistant.' },
+}
+export function listSouls() { return Object.keys(SOULS) }
+export function getSoul(name) { return SOULS[name] || SOULS.classic }
+export function applySoul(name) {
+    const soul = getSoul(name)
+    setActiveSkin(soul.skin)
+    saveConfigValue('agent.persona', soul.persona)
+    return soul
+}
+export function activeSoul() {
+    const skinName = getActiveSkin().name
+    return Object.entries(SOULS).find(([_, s]) => s.skin === skinName)?.[0] || 'classic'
+}

package/src/cli/dingtalk_auth.js

@@ -0,0 +1,12 @@
+import { getAuthStore } from '../auth.js'
+const KEY = 'DINGTALK_ACCESS_TOKEN'
+export async function getDingtalkToken() {
+    if (process.env.DINGTALK_ACCESS_TOKEN) return { source: 'env', value: process.env.DINGTALK_ACCESS_TOKEN }
+    const stored = await getAuthStore().getCredential(KEY)
+    return stored?.value ? { source: 'auth-store', value: stored.value } : { source: 'none', value: null }
+}
+export async function setDingtalkToken(token) { return await getAuthStore().setCredential(KEY, token) }
+export async function fetchTokenFromAppKey({ appKey, appSecret }) {
+    const r = await fetch('https://oapi.dingtalk.com/gettoken?appkey=' + encodeURIComponent(appKey) + '&appsecret=' + encodeURIComponent(appSecret))
+    return await r.json()
+}

package/src/cli/doctor.js

@@ -0,0 +1,15 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { spawnSync } from 'node:child_process'
+import { getFophHome } from '../home.js'
+const CHECKS = [
+    { name: 'freddie-home', run: () => fs.existsSync(getFophHome()) ? { ok: true } : { ok: false, fix: 'mkdir -p ' + getFophHome() } },
+    { name: 'node-version', run: () => { const v = process.versions.node; const major = Number(v.split('.')[0]); return major >= 20 ? { ok: true, value: v } : { ok: false, fix: 'install node >=20', value: v } } },
+    { name: 'better-sqlite3', run: () => { try { require.resolve('better-sqlite3'); return { ok: true } } catch { return { ok: false, fix: 'npm install' } } } },
+    { name: 'gh-cli', run: () => { const r = spawnSync('gh', ['--version'], { encoding: 'utf8' }); return r.status === 0 ? { ok: true, value: r.stdout.split('\n')[0] } : { ok: false, fix: 'install gh CLI' } } },
+    { name: 'git', run: () => { const r = spawnSync('git', ['--version'], { encoding: 'utf8' }); return r.status === 0 ? { ok: true, value: r.stdout.trim() } : { ok: false, fix: 'install git' } } },
+    { name: 'config-file', run: () => { const p = path.join(getFophHome(), 'config.yaml'); return fs.existsSync(p) ? { ok: true } : { ok: false, fix: 'freddie setup' } } },
+]
+export function runDoctor() {
+    return CHECKS.map(c => { try { return { name: c.name, ...c.run() } } catch (e) { return { name: c.name, ok: false, error: String(e.message || e) } } })
+}

package/src/cli/dump.js

@@ -0,0 +1,11 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { getFophHome } from '../home.js'
+import { listSessions, getMessages } from '../sessions.js'
+import { loadConfig } from '../config.js'
+export async function dumpAll(outFile = null) {
+    const out = { ts: Date.now(), foph_home: getFophHome(), config: loadConfig(), sessions: listSessions(1000).map(s => ({ ...s, messages: getMessages(s.id) })) }
+    const json = JSON.stringify(out, null, 2)
+    if (outFile) { fs.mkdirSync(path.dirname(outFile), { recursive: true }); fs.writeFileSync(outFile, json, 'utf8'); return { written: outFile, bytes: json.length } }
+    return out
+}

package/src/cli/env_loader.js

@@ -0,0 +1,25 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { getFophHome } from '../home.js'
+const RE = /^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/
+function parse(text) {
+    const out = {}
+    for (const line of String(text).split('\n')) {
+        const t = line.trim()
+        if (!t || t.startsWith('#')) continue
+        const m = t.match(RE)
+        if (m) out[m[1]] = m[2].replace(/^["']|["']$/g, '')
+    }
+    return out
+}
+export function loadEnvFile(file = null) {
+    const candidates = file ? [file] : [path.join(getFophHome(), '.env'), path.join(process.cwd(), '.env')]
+    const merged = {}
+    for (const f of candidates) if (fs.existsSync(f)) Object.assign(merged, parse(fs.readFileSync(f, 'utf8')))
+    return merged
+}
+export function applyEnvFile(file = null) {
+    const env = loadEnvFile(file)
+    for (const [k, v] of Object.entries(env)) if (!(k in process.env)) process.env[k] = v
+    return Object.keys(env).length
+}

package/src/cli/fallback_cmd.js

@@ -0,0 +1,9 @@
+import { resolveCommand, COMMAND_REGISTRY } from '../commands/registry.js'
+import { fuzzyMatch } from '../utils.js'
+export function suggest(input) {
+    const slash = input.replace(/^\//, '').split(/\s+/)[0]
+    if (resolveCommand(input)) return null
+    const scored = COMMAND_REGISTRY.map(c => ({ name: c.name, score: fuzzyMatch(slash, c.name) })).filter(s => s.score > 0)
+    scored.sort((a, b) => b.score - a.score)
+    return scored.slice(0, 3).map(s => '/' + s.name)
+}

package/src/cli/gateway_cli.js

@@ -0,0 +1,17 @@
+import { Gateway } from '../gateway/run.js'
+import { WebhookAdapter } from '../gateway/platforms/webhook.js'
+import { ApiServerAdapter } from '../gateway/platforms/api_server.js'
+import { registerBuiltinHooks } from '../gateway/builtin_hooks/index.js'
+let _gateway = null
+export async function startGateway({ port = 0, hooks = true } = {}) {
+    if (_gateway) return _gateway
+    const wh = new WebhookAdapter({ port })
+    const api = new ApiServerAdapter({ port: 0 })
+    const gw = new Gateway({ platforms: { webhook: wh, api_server: api } })
+    if (hooks) registerBuiltinHooks(gw)
+    await gw.start()
+    _gateway = { gw, webhook: wh, api }
+    return { webhookPort: wh.port, apiPort: api.port }
+}
+export async function stopGateway() { if (_gateway) { await _gateway.gw.stop(); _gateway = null } return { stopped: true } }
+export function gatewayStatus() { return _gateway ? { running: true, webhookPort: _gateway.webhook.port, apiPort: _gateway.api.port } : { running: false } }

package/src/cli/hooks.js

@@ -0,0 +1,9 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { getFophHome } from '../home.js'
+function file() { return path.join(getFophHome(), 'hooks.json') }
+export function loadHooks() { try { return JSON.parse(fs.readFileSync(file(), 'utf8')) } catch { return { pre_command: [], post_command: [], pre_tool: [], post_tool: [] } } }
+export function saveHooks(h) { fs.writeFileSync(file(), JSON.stringify(h, null, 2), 'utf8') }
+export function addHook(stage, command) { const h = loadHooks(); (h[stage] = h[stage] || []).push(command); saveHooks(h); return h }
+export function removeHook(stage, idx) { const h = loadHooks(); h[stage] = (h[stage] || []).filter((_, i) => i !== idx); saveHooks(h); return h }
+export function listHooks() { return loadHooks() }

package/src/cli/interactive.js

@@ -0,0 +1,61 @@
+import readline from 'node:readline'
+import { runTurn } from '../agent/machine.js'
+import { resolveCommand, COMMAND_REGISTRY, COMMANDS_BY_CATEGORY } from '../commands/registry.js'
+import { getActiveSkin } from '../skin/engine.js'
+import { createSession, appendMessage } from '../sessions.js'
+import { listAllProfiles, switchProfile } from '../commands/profile.js'
+
+const HANDLERS = {
+    help: () => {
+        const out = []
+        for (const [cat, cmds] of Object.entries(COMMANDS_BY_CATEGORY)) {
+            out.push(`\n# ${cat}`)
+            for (const c of cmds) out.push(`  /${c.name}${c.args_hint ? ' ' + c.args_hint : ''}\t${c.description}`)
+        }
+        return out.join('\n')
+    },
+    quit: (state) => { state.exit = true; return 'bye.' },
+    profile: (_s, args) => {
+        if (!args[0] || args[0] === 'list') return listAllProfiles().join('\n')
+        if (args[0] === 'switch' && args[1]) { switchProfile(args[1]); return 'switched: ' + args[1] }
+        return 'usage: /profile [list|switch <name>]'
+    },
+    sessions: () => 'Use the CLI: freddie sessions',
+    clear: (state) => { state.messages = []; return 'cleared.' },
+}
+
+export async function interactive({ callLLM, input = process.stdin, output = process.stdout } = {}) {
+    const skin = getActiveSkin()
+    const state = { messages: [], session: createSession({ platform: 'cli' }), exit: false }
+    output.write(`${skin.branding.welcome}\n`)
+    const rl = readline.createInterface({ input, output, terminal: input.isTTY })
+    const prompt = () => { if (!state.exit) rl.setPrompt(skin.branding.prompt_symbol); rl.prompt() }
+    rl.on('line', async (raw) => {
+        const line = raw.trim()
+        if (!line) return prompt()
+        if (line.startsWith('/')) {
+            const parts = line.slice(1).split(/\s+/)
+            const name = resolveCommand('/' + parts[0])
+            const handler = HANDLERS[name]
+            if (!handler) { output.write(`unknown command: /${parts[0]}\n`); return prompt() }
+            output.write(handler(state, parts.slice(1)) + '\n')
+            if (state.exit) rl.close()
+            else prompt()
+            return
+        }
+        appendMessage(state.session, { role: 'user', content: line })
+        try {
+            const out = await runTurn({ prompt: line, messages: state.messages, callLLM, timeoutMs: 60000 })
+            state.messages = out.messages
+            const reply = out.result || out.error || '(no response)'
+            output.write(`${skin.branding.response_label}${reply}\n`)
+            appendMessage(state.session, { role: 'assistant', content: reply })
+        } catch (e) {
+            output.write(`error: ${e.message}\n`)
+        }
+        prompt()
+    })
+    rl.on('close', () => {})
+    prompt()
+    return new Promise(resolve => rl.on('close', resolve))
+}

package/src/cli/logs.js

@@ -0,0 +1,32 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { getFophHome } from '../home.js'
+export function listLogFiles() {
+    const dir = path.join(getFophHome(), 'logs')
+    if (!fs.existsSync(dir)) return []
+    return fs.readdirSync(dir).filter(f => f.endsWith('.log')).map(f => f.replace(/\.log$/, ''))
+}
+export function tail(subsystem, { max = 100, level = null } = {}) {
+    const file = path.join(getFophHome(), 'logs', subsystem + '.log')
+    if (!fs.existsSync(file)) return []
+    const lines = fs.readFileSync(file, 'utf8').trim().split('\n').filter(Boolean)
+    let parsed = lines.map(l => { try { return JSON.parse(l) } catch { return { raw: l } } })
+    if (level) { const SEV = { debug: 10, info: 20, warning: 30, error: 40 }; const min = SEV[level] || 20; parsed = parsed.filter(r => (SEV[r.severity] || 0) >= min) }
+    return parsed.slice(-max)
+}
+export async function followLog(subsystem, onLine) {
+    const file = path.join(getFophHome(), 'logs', subsystem + '.log')
+    let pos = fs.existsSync(file) ? fs.statSync(file).size : 0
+    const watcher = fs.watch(path.dirname(file), (_, name) => {
+        if (name !== subsystem + '.log') return
+        const stat = fs.statSync(file)
+        if (stat.size <= pos) { pos = 0; return }
+        const buf = Buffer.alloc(stat.size - pos)
+        const fd = fs.openSync(file, 'r')
+        fs.readSync(fd, buf, 0, buf.length, pos)
+        fs.closeSync(fd)
+        pos = stat.size
+        for (const l of buf.toString('utf8').split('\n').filter(Boolean)) try { onLine(JSON.parse(l)) } catch { onLine({ raw: l }) }
+    })
+    return () => watcher.close()
+}

package/src/cli/main.js

@@ -0,0 +1,7 @@
+import { Command } from 'commander'
+export function buildMainProgram() {
+    const program = new Command()
+    program.name('freddie').version('0.5.0').description('Freddie — JS rebuild of hermes-agent')
+    return program
+}
+export { buildMainProgram as createCli }

package/src/cli/mcp_config.js

@@ -0,0 +1,9 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { getFophHome } from '../home.js'
+function file() { return path.join(getFophHome(), 'mcp.json') }
+export function loadMcpConfig() { try { return JSON.parse(fs.readFileSync(file(), 'utf8')) } catch { return { servers: {} } } }
+export function saveMcpConfig(cfg) { fs.writeFileSync(file(), JSON.stringify(cfg, null, 2), 'utf8') }
+export function addServer(name, { command, args = [], env = {} }) { const c = loadMcpConfig(); c.servers[name] = { command, args, env }; saveMcpConfig(c); return c.servers[name] }
+export function removeServer(name) { const c = loadMcpConfig(); delete c.servers[name]; saveMcpConfig(c); return name }
+export function listServers() { return Object.entries(loadMcpConfig().servers).map(([n, s]) => ({ name: n, ...s })) }

package/src/cli/memory_setup.js

@@ -0,0 +1,12 @@
+import { saveConfigValue } from '../config.js'
+import { getAuthStore } from '../auth.js'
+import { listMemoryProviders } from '../plugins/memory/provider.js'
+export const PROVIDER_ENV = { honcho: 'HONCHO_API_KEY', mem0: 'MEM0_API_KEY', supermemory: 'SUPERMEMORY_API_KEY', byterover: 'BYTEROVER_API_KEY', hindsight: 'HINDSIGHT_API_KEY', openviking: 'OPENVIKING_API_KEY', retaindb: 'RETAINDB_API_KEY' }
+export function listProviders() { return listMemoryProviders() }
+export async function configureProvider(name, apiKey, options = {}) {
+    if (!listMemoryProviders().includes(name)) throw new Error('unknown memory provider: ' + name)
+    saveConfigValue('memory.provider', name)
+    saveConfigValue('memory.options', options)
+    if (apiKey && PROVIDER_ENV[name]) await getAuthStore().setCredential(PROVIDER_ENV[name], apiKey)
+    return { configured: name, hasKey: Boolean(apiKey) }
+}

package/src/cli/model_catalog.js

@@ -0,0 +1,23 @@
+import { getModelContextLength } from '../agent/model_metadata.js'
+import { priceFor } from '../agent/usage_pricing.js'
+const CATALOG = [
+    { provider: 'anthropic', id: 'claude-opus-4-7', tags: ['flagship'] },
+    { provider: 'anthropic', id: 'claude-sonnet-4-6', tags: ['default'] },
+    { provider: 'anthropic', id: 'claude-haiku-4-5', tags: ['fast'] },
+    { provider: 'openai', id: 'gpt-5', tags: ['flagship'] },
+    { provider: 'openai', id: 'gpt-5-mini', tags: ['fast'] },
+    { provider: 'openai', id: 'gpt-4o', tags: ['vision'] },
+    { provider: 'openai', id: 'o3', tags: ['reasoning'] },
+    { provider: 'google', id: 'gemini-2.5-pro', tags: ['flagship', 'long-context'] },
+    { provider: 'google', id: 'gemini-2.5-flash', tags: ['fast'] },
+    { provider: 'xai', id: 'grok-4', tags: ['flagship'] },
+    { provider: 'deepseek', id: 'deepseek-v3', tags: ['cheap'] },
+    { provider: 'groq', id: 'llama-3.3-70b', tags: ['fast'] },
+]
+export function listCatalog({ provider } = {}) {
+    return CATALOG.filter(m => !provider || m.provider === provider).map(m => ({ ...m, contextLength: getModelContextLength(m.id), pricing: priceFor(m.id) }))
+}
+export function findInCatalog(id) {
+    const m = CATALOG.find(x => x.id === id || id.startsWith(x.id))
+    return m ? { ...m, contextLength: getModelContextLength(m.id), pricing: priceFor(m.id) } : null
+}

package/src/cli/model_normalize.js

@@ -0,0 +1,12 @@
+const ALIASES = {
+    sonnet: 'claude-sonnet-4-6', opus: 'claude-opus-4-7', haiku: 'claude-haiku-4-5',
+    gpt5: 'gpt-5', gpt5mini: 'gpt-5-mini', '4o': 'gpt-4o', '4omini': 'gpt-4o-mini',
+    flash: 'gemini-2.5-flash', pro: 'gemini-2.5-pro',
+    grok: 'grok-4', llama: 'llama-3.3-70b', dsv3: 'deepseek-v3',
+}
+export function normalizeModel(input) {
+    if (!input) return null
+    const lower = String(input).trim().toLowerCase().replace(/[^a-z0-9-]/g, '')
+    return ALIASES[lower] || input
+}
+export function listAliases() { return { ...ALIASES } }

package/src/cli/model_switch.js

@@ -0,0 +1,11 @@
+import { saveConfigValue, getConfigValue } from '../config.js'
+import { normalizeModel } from './model_normalize.js'
+import { findInCatalog } from './model_catalog.js'
+export function activeModel() { return getConfigValue('agent.model') }
+export function switchModel(input) {
+    const id = normalizeModel(input)
+    const cat = findInCatalog(id)
+    saveConfigValue('agent.model', id)
+    if (cat?.provider) saveConfigValue('agent.provider', cat.provider)
+    return { model: id, provider: cat?.provider, contextLength: cat?.contextLength }
+}

package/src/cli/models.js

@@ -0,0 +1,13 @@
+import { listCatalog, findInCatalog } from './model_catalog.js'
+import { switchModel, activeModel } from './model_switch.js'
+export const ACTIONS = {
+    list: ({ provider }) => ({ models: listCatalog({ provider }) }),
+    get: ({ id }) => ({ model: findInCatalog(id) }),
+    use: ({ id }) => switchModel(id),
+    active: () => ({ active: activeModel() }),
+}
+export async function modelsSubcommand(action = 'list', args = {}) {
+    const fn = ACTIONS[action]
+    if (!fn) return { error: 'unknown action: ' + action, valid: Object.keys(ACTIONS) }
+    return fn(args)
+}

package/src/cli/nous_subscription.js

@@ -0,0 +1,12 @@
+import { getAuthStore } from '../auth.js'
+const KEY = 'NOUS_API_KEY'
+export async function nousStatus() {
+    const k = process.env.NOUS_API_KEY || (await getAuthStore().getCredential(KEY))?.value
+    if (!k) return { active: false, hint: 'freddie nous-subscription set <key>' }
+    try {
+        const r = await fetch('https://api.nousresearch.com/v1/me', { headers: { authorization: 'Bearer ' + k } })
+        return { active: r.ok, status: r.status }
+    } catch (e) { return { active: false, error: String(e.message || e) } }
+}
+export async function setKey(key) { return await getAuthStore().setCredential(KEY, key) }
+export async function clearKey() { return await getAuthStore().deleteCredential(KEY) }

package/src/cli/oneshot.js

@@ -0,0 +1,6 @@
+import { runTurn } from '../agent/machine.js'
+export async function oneshot({ prompt, model = null, callLLM = null, timeoutMs = 60000 } = {}) {
+    if (!prompt) throw new Error('prompt required')
+    const out = await runTurn({ prompt, model, callLLM, timeoutMs })
+    return { result: out.result || '', error: out.error || null, iterations: out.iterations }
+}

package/src/cli/pairing.js

@@ -0,0 +1,21 @@
+import crypto from 'node:crypto'
+import { getAuthStore } from '../auth.js'
+const _pending = new Map()
+export function generatePairCode() {
+    const code = crypto.randomBytes(3).toString('hex').toUpperCase()
+    const secret = crypto.randomBytes(32).toString('hex')
+    _pending.set(code, { secret, ts: Date.now() })
+    setTimeout(() => _pending.delete(code), 5 * 60_000)
+    return { code, secret }
+}
+export async function completePairing(code, deviceName) {
+    const p = _pending.get(code)
+    if (!p) return { error: 'invalid or expired code' }
+    _pending.delete(code)
+    await getAuthStore().setCredential('paired-device:' + deviceName, p.secret)
+    return { paired: deviceName }
+}
+export async function listPaired() {
+    const all = await getAuthStore().listCredentials()
+    return all.filter(n => n.startsWith('paired-device:')).map(n => n.replace('paired-device:', ''))
+}

package/src/cli/platforms.js

@@ -0,0 +1,14 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+export async function listPlatforms() {
+    const dir = path.resolve(__dirname, '../gateway/platforms')
+    const out = []
+    for (const f of fs.readdirSync(dir).filter(f => f.endsWith('.js'))) {
+        const mod = await import('file://' + path.join(dir, f).replace(/\\/g, '/'))
+        const cls = Object.values(mod).find(v => typeof v === 'function' && /Adapter$/.test(v.name))
+        if (cls) { try { const inst = new cls({}); out.push({ name: f.replace(/\.js$/, ''), requiresEnv: inst.getRequiredEnv?.() || [] }) } catch { out.push({ name: f.replace(/\.js$/, ''), requiresEnv: [] }) } }
+    }
+    return out
+}

package/src/cli/plugins.js

@@ -0,0 +1,4 @@
+import { pluginManager } from '../plugins/manager.js'
+export async function listPluginsInstalled() { await pluginManager.discoverPlugins(); return pluginManager.plugins.map(p => ({ name: p.name, dir: p.dir || null })) }
+export function listHooks() { return Object.fromEntries(Object.entries(pluginManager.hooks).map(([k, v]) => [k, v.length])) }
+export function listCliCommands() { return pluginManager.cliCommands || [] }

package/src/cli/plugins_cmd.js

@@ -0,0 +1,21 @@
+import { listPluginsInstalled, listHooks, listCliCommands } from './plugins.js'
+import fs from 'node:fs'
+import path from 'node:path'
+import { getFophHome } from '../home.js'
+export async function pluginsSubcommand(action = 'list', { name, body } = {}) {
+    if (action === 'list') return { plugins: await listPluginsInstalled(), hooks: listHooks(), cliCommands: listCliCommands().length }
+    if (action === 'install') {
+        if (!name || !body) return { error: 'name + body required' }
+        const dir = path.join(getFophHome(), 'plugins', name)
+        fs.mkdirSync(dir, { recursive: true })
+        fs.writeFileSync(path.join(dir, 'package.json'), JSON.stringify({ name, main: 'index.js' }, null, 2))
+        fs.writeFileSync(path.join(dir, 'index.js'), body, 'utf8')
+        return { installed: dir }
+    }
+    if (action === 'uninstall') {
+        const dir = path.join(getFophHome(), 'plugins', name)
+        if (fs.existsSync(dir)) { fs.rmSync(dir, { recursive: true, force: true }); return { uninstalled: name } }
+        return { error: 'not found' }
+    }
+    return { error: 'unknown action' }
+}

package/src/cli/profiles_cli.js

@@ -0,0 +1,6 @@
+export { createProfile, deleteProfile, switchProfile, listAllProfiles } from '../commands/profile.js'
+import { listAllProfiles } from '../commands/profile.js'
+import { applyProfileOverride, getProfilesRoot, listProfiles } from '../home.js'
+export function activeProfile() { return process.env.FREDDIE_PROFILE || 'default' }
+export function listAll() { return { active: activeProfile(), all: listAllProfiles(), root: getProfilesRoot() } }
+export function setActive(name) { applyProfileOverride(name); return { active: name || 'default' } }

package/src/cli/providers.js

@@ -0,0 +1,18 @@
+import { resolveKey, listProviders as srcList } from '../agent/credential_sources.js'
+import { saveConfigValue, getConfigValue } from '../config.js'
+import { getAuthStore } from '../auth.js'
+export function listProviders() { return srcList() }
+export async function status() {
+    const out = []
+    for (const p of listProviders()) {
+        const k = await resolveKey(p)
+        out.push({ provider: p, source: k.source, configured: k.value != null })
+    }
+    return { providers: out, active: getConfigValue('agent.provider') }
+}
+export async function setKey(provider, key) {
+    const env = (provider.toUpperCase() + '_API_KEY')
+    await getAuthStore().setCredential(env, key)
+    return { provider, stored: env }
+}
+export function setActive(provider) { saveConfigValue('agent.provider', provider); return { active: provider } }

package/src/cli/pty_bridge.js

@@ -0,0 +1,16 @@
+import { spawn } from 'node:child_process'
+const _ptys = new Map()
+export function openPty({ shell = process.platform === 'win32' ? 'cmd' : process.env.SHELL || 'sh', cwd = process.cwd(), env = process.env } = {}) {
+    const id = 'pty-' + Date.now() + '-' + Math.random().toString(36).slice(2, 6)
+    const child = spawn(shell, [], { cwd, env, stdio: ['pipe', 'pipe', 'pipe'] })
+    const buf = { stdout: '', stderr: '' }
+    child.stdout?.on('data', d => buf.stdout += d.toString())
+    child.stderr?.on('data', d => buf.stderr += d.toString())
+    _ptys.set(id, { child, buf })
+    child.on('exit', () => _ptys.delete(id))
+    return id
+}
+export function ptyWrite(id, data) { const p = _ptys.get(id); if (!p) return { error: 'unknown' }; p.child.stdin?.write(data); return { ok: true } }
+export function ptyRead(id) { const p = _ptys.get(id); if (!p) return { error: 'unknown' }; const out = { ...p.buf }; p.buf.stdout = ''; p.buf.stderr = ''; return out }
+export function ptyClose(id) { const p = _ptys.get(id); if (!p) return { error: 'unknown' }; try { p.child.kill('SIGTERM') } catch {}; _ptys.delete(id); return { closed: id } }
+export function ptyList() { return [..._ptys.keys()] }

package/src/cli/relaunch.js

@@ -0,0 +1,7 @@
+export function relaunch({ argv = process.argv } = {}) {
+    const { spawn } = require('node:child_process')
+    const child = spawn(argv[0], argv.slice(1), { detached: true, stdio: 'ignore', env: process.env })
+    child.unref()
+    setTimeout(() => process.exit(0), 100)
+    return { pid: child.pid }
+}

package/src/cli/runtime_provider.js

@@ -0,0 +1,9 @@
+import { getConfigValue } from '../config.js'
+import { resolveKey } from '../agent/credential_sources.js'
+export async function activeRuntime() {
+    const provider = getConfigValue('agent.provider', 'anthropic')
+    const model = getConfigValue('agent.model', '')
+    const key = await resolveKey(provider)
+    return { provider, model, hasKey: key.value != null, keySource: key.source }
+}
+export const KNOWN_RUNTIMES = ['anthropic', 'openai', 'google', 'xai', 'groq', 'openrouter', 'deepseek', 'mistral', 'lmstudio', 'ollama']