agent-office 0.5.0 → 0.6.1

package/dist/manage/components/TailMessages.js

@@ -1,126 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useEffect, useState } from "react";
-import { Box, Text, useInput } from "ink";
-import { Select, Spinner } from "@inkjs/ui";
-import { useApi, useAsyncState } from "../hooks/useApi.js";
-export function TailMessages({ serverUrl, password, onBack, contentHeight }) {
-    const { listSessions, getMessages } = useApi(serverUrl, password);
-    const { run: runList } = useAsyncState();
-    const [sessions, setSessions] = useState([]);
-    const [sessionsLoading, setSessionsLoading] = useState(true);
-    const [stage, setStage] = useState("select");
-    const [selectedName, setSelectedName] = useState(null);
-    const [messages, setMessages] = useState([]);
-    const [error, setError] = useState(null);
-    const [scrollOffset, setScrollOffset] = useState(0);
-    useEffect(() => {
-        runList(listSessions).then((rows) => {
-            setSessions(rows ?? []);
-            setSessionsLoading(false);
-        });
-    }, []);
-    // Scroll through messages with arrow keys when viewing
-    useInput((input, key) => {
-        if (stage !== "viewing")
-            return;
-        if (key.upArrow)
-            setScrollOffset((o) => Math.max(0, o - 1));
-        if (key.downArrow)
-            setScrollOffset((o) => o + 1);
-    });
-    const handleSelect = async (name) => {
-        setSelectedName(name);
-        setStage("loading");
-        try {
-            const msgs = await getMessages(name, 50);
-            setMessages(msgs);
-            setScrollOffset(Infinity);
-            setStage("viewing");
-        }
-        catch (err) {
-            setError(err instanceof Error ? err.message : String(err));
-            setStage("error");
-        }
-    };
-    if (sessionsLoading) {
-        return (_jsx(Box, { height: contentHeight, alignItems: "center", justifyContent: "center", children: _jsx(Spinner, { label: "Loading sessions..." }) }));
-    }
-    if (stage === "select") {
-        if (sessions.length === 0) {
-            return (_jsx(Box, { height: contentHeight, alignItems: "center", justifyContent: "center", children: _jsx(Text, { dimColor: true, children: "No sessions yet. Create one first." }) }));
-        }
-        return (_jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsx(Text, { bold: true, children: "Tail Messages" }), _jsx(Text, { dimColor: true, children: "Select a session:" }), _jsx(Select, { options: sessions.map((s) => ({ label: s.name, value: s.name })), onChange: handleSelect })] }));
-    }
-    if (stage === "loading") {
-        return (_jsx(Box, { height: contentHeight, alignItems: "center", justifyContent: "center", children: _jsx(Spinner, { label: `Fetching messages for "${selectedName}"...` }) }));
-    }
-    if (stage === "error") {
-        return (_jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsx(Text, { bold: true, children: "Tail Messages" }), _jsxs(Text, { color: "red", children: ["Error: ", error] })] }));
-    }
-    // viewing — render messages with scroll
-    const messageLines = [];
-    for (const msg of messages) {
-        for (const part of msg.parts) {
-            if (part.type === "text" && part.text) {
-                // Split multiline text into individual lines for rendering
-                const lines = part.text.split("\n");
-                for (let i = 0; i < lines.length; i++) {
-                    messageLines.push({ role: msg.role, text: i === 0 ? lines[i] : `  ${lines[i]}` });
-                }
-                messageLines.push({ role: msg.role, text: "" }); // blank line between parts
-            }
-            else if (part.type === "tool") {
-                // Tool part has: tool (string), input, output
-                const toolName = typeof part.tool === "string" ? part.tool : String(part.tool ?? "unknown");
-                messageLines.push({ role: msg.role, text: "" }); // Blank line before tool
-                messageLines.push({ role: msg.role, text: `▶ Tool: ${toolName}` });
-                if (part.input !== undefined) {
-                    // Try to pretty-print input if it's an object
-                    let inputStr;
-                    if (typeof part.input === "object" && part.input !== null) {
-                        inputStr = JSON.stringify(part.input, null, 2);
-                    }
-                    else {
-                        inputStr = String(part.input);
-                    }
-                    const lines = inputStr.split("\n");
-                    for (let i = 0; i < Math.min(lines.length, 15); i++) {
-                        messageLines.push({ role: msg.role, text: `  ${lines[i]}` });
-                    }
-                    if (lines.length > 15) {
-                        messageLines.push({ role: msg.role, text: `  [...] (${lines.length - 15} more lines)` });
-                    }
-                }
-                if (part.output !== undefined) {
-                    // Show output type and preview
-                    let outputPreview;
-                    if (typeof part.output === "object" && part.output !== null) {
-                        outputPreview = JSON.stringify(part.output, null, 2).slice(0, 200);
-                    }
-                    else if (typeof part.output === "string") {
-                        outputPreview = part.output.slice(0, 200);
-                    }
-                    else {
-                        outputPreview = String(part.output).slice(0, 200);
-                    }
-                    const outputType = typeof part.output === "object" ? "object" : typeof part.output;
-                    messageLines.push({ role: msg.role, text: `  ${"—".repeat(40)}` });
-                    messageLines.push({ role: msg.role, text: `  Result (${outputType}):` });
-                    const lines = outputPreview.split("\n");
-                    for (let i = 0; i < Math.min(lines.length, 5); i++) {
-                        messageLines.push({ role: msg.role, text: `  ${lines[i]}` });
-                    }
-                    if (lines.length > 5 || outputPreview.length >= 200) {
-                        messageLines.push({ role: msg.role, text: "  [...]" });
-                    }
-                }
-                messageLines.push({ role: msg.role, text: "" }); // Blank line after tool
-            }
-        }
-    }
-    const viewHeight = contentHeight - 3; // header + separator
-    const maxOffset = Math.max(0, messageLines.length - viewHeight);
-    const clampedOffset = Math.min(scrollOffset, maxOffset);
-    const visible = messageLines.slice(clampedOffset, clampedOffset + viewHeight);
-    return (_jsxs(Box, { flexDirection: "column", gap: 0, children: [_jsxs(Box, { gap: 2, marginBottom: 1, children: [_jsx(Text, { bold: true, children: "Messages" }), _jsx(Text, { color: "cyan", children: selectedName }), _jsxs(Text, { dimColor: true, children: ["(", messages.length, " messages)"] })] }), _jsx(Box, { flexDirection: "column", height: viewHeight, overflow: "hidden", children: visible.length === 0 ? (_jsx(Text, { dimColor: true, children: "No messages in this session yet." })) : (visible.map((line, i) => (_jsx(Box, { children: line.role === "user" ? (_jsx(Text, { color: "green", children: line.text })) : (_jsx(Text, { children: line.text })) }, i)))) }), messageLines.length > viewHeight && (_jsxs(Text, { dimColor: true, children: ["[", clampedOffset + 1, "-", Math.min(clampedOffset + viewHeight, messageLines.length), "/", messageLines.length, " lines] \u2191\u2193 scroll"] }))] }));
-}

package/dist/manage/hooks/useApi.d.ts

@@ -1,147 +0,0 @@
-export interface Session {
-    id: number;
-    name: string;
-    session_id: string;
-    agent_code: string;
-    agent: string | null;
-    status: string | null;
-    created_at: string;
-}
-export interface AppMode {
-    name: string;
-    description: string;
-    model: string;
-}
-export interface MessagePart {
-    type: "text" | "tool" | "tool-output";
-    text?: string;
-    tool?: string;
-    input?: unknown;
-    output?: unknown;
-    data?: unknown;
-}
-export interface SessionMessage {
-    role: "user" | "assistant";
-    parts: MessagePart[];
-}
-export interface MailMessage {
-    id: number;
-    from_name: string;
-    to_name: string;
-    body: string;
-    read: boolean;
-    injected: boolean;
-    created_at: string;
-}
-export interface Config {
-    [key: string]: string;
-}
-export interface CronJob {
-    id: number;
-    name: string;
-    session_name: string;
-    schedule: string;
-    timezone: string | null;
-    message: string;
-    enabled: boolean;
-    created_at: string;
-    last_run: string | null;
-    next_run: string | null;
-}
-export interface CronHistoryEntry {
-    id: number;
-    cron_job_id: number;
-    executed_at: string;
-    success: boolean;
-    error_message: string | null;
-}
-export interface CronRequest {
-    id: number;
-    name: string;
-    session_name: string;
-    schedule: string;
-    timezone: string | null;
-    message: string;
-    status: "pending" | "approved" | "rejected";
-    requested_at: string;
-    reviewed_at: string | null;
-    reviewed_by: string | null;
-    reviewer_notes: string | null;
-}
-export declare function useApi(serverUrl: string, password: string): {
-    listSessions: () => Promise<Session[]>;
-    createSession: (name: string, agent: string) => Promise<Session>;
-    deleteSession: (name: string) => Promise<void>;
-    updateSessionAgent: (name: string, agent: string) => Promise<Session>;
-    checkHealth: () => Promise<boolean>;
-    getMessages: (name: string, limit?: number) => Promise<SessionMessage[]>;
-    injectText: (name: string, text: string) => Promise<{
-        ok: boolean;
-        messageID: string;
-    }>;
-    revertToStart: (name: string) => Promise<{
-        ok: boolean;
-        messageID: string;
-    }>;
-    revertAll: () => Promise<{
-        ok: boolean;
-        total: number;
-        results: Array<{
-            name: string;
-            ok: boolean;
-            error?: string;
-        }>;
-    }>;
-    regenerateCode: (name: string) => Promise<Session>;
-    getConfig: () => Promise<Config>;
-    setConfig: (key: string, value: string) => Promise<{
-        ok: boolean;
-        key: string;
-        value: string;
-    }>;
-    getMailMessages: (name: string, options?: {
-        sent?: boolean;
-        unreadOnly?: boolean;
-    }) => Promise<MailMessage[]>;
-    sendMailMessage: (from: string, to: string[], body: string) => Promise<{
-        ok: boolean;
-        results: Array<{
-            to: string;
-            messageId: number;
-            injected: boolean;
-        }>;
-    }>;
-    markMessageRead: (id: number) => Promise<MailMessage>;
-    getModes: () => Promise<AppMode[]>;
-    listCrons: (sessionName?: string) => Promise<CronJob[]>;
-    createCron: (data: {
-        name: string;
-        session_name: string;
-        schedule: string;
-        message: string;
-        timezone?: string;
-    }) => Promise<CronJob>;
-    deleteCron: (id: number) => Promise<{
-        deleted: boolean;
-        id: number;
-        name: string;
-    }>;
-    enableCron: (id: number) => Promise<CronJob>;
-    disableCron: (id: number) => Promise<CronJob>;
-    getCronHistory: (id: number, limit?: number) => Promise<CronHistoryEntry[]>;
-    listCronRequests: (filters?: {
-        status?: string;
-        sessionName?: string;
-    }) => Promise<CronRequest[]>;
-    approveCronRequest: (id: number, notes?: string) => Promise<{
-        request: CronRequest;
-        cron_job: CronJob;
-    }>;
-    rejectCronRequest: (id: number, notes?: string) => Promise<CronRequest>;
-};
-export declare function useAsyncState<T>(): {
-    run: (fn: () => Promise<T>) => Promise<T | null>;
-    data: T | null;
-    loading: boolean;
-    error: string | null;
-};

package/dist/manage/hooks/useApi.js

@@ -1,181 +0,0 @@
-import { useState, useCallback } from "react";
-function makeHeaders(password) {
-    return {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${password}`,
-    };
-}
-async function apiFetch(url, password, init) {
-    const res = await fetch(url, {
-        ...init,
-        headers: {
-            ...makeHeaders(password),
-            ...init?.headers,
-        },
-    });
-    if (res.status === 401) {
-        throw new Error("Unauthorized: check your --password");
-    }
-    const body = await res.json();
-    if (!res.ok) {
-        const msg = body.error ?? `HTTP ${res.status}`;
-        throw new Error(msg);
-    }
-    return body;
-}
-export function useApi(serverUrl, password) {
-    const base = serverUrl.replace(/\/$/, "");
-    const listSessions = useCallback(async () => {
-        return apiFetch(`${base}/sessions`, password);
-    }, [base, password]);
-    const createSession = useCallback(async (name, agent) => {
-        return apiFetch(`${base}/sessions`, password, {
-            method: "POST",
-            body: JSON.stringify({ name, agent }),
-        });
-    }, [base, password]);
-    const getModes = useCallback(async () => {
-        return apiFetch(`${base}/modes`, password);
-    }, [base, password]);
-    const deleteSession = useCallback(async (name) => {
-        await apiFetch(`${base}/sessions/${encodeURIComponent(name)}`, password, {
-            method: "DELETE",
-        });
-    }, [base, password]);
-    const updateSessionAgent = useCallback(async (name, agent) => {
-        return apiFetch(`${base}/sessions/${encodeURIComponent(name)}/agent`, password, {
-            method: "PATCH",
-            body: JSON.stringify({ agent }),
-        });
-    }, [base, password]);
-    const checkHealth = useCallback(async () => {
-        try {
-            await apiFetch(`${base}/health`, password);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }, [base, password]);
-    const getMessages = useCallback(async (name, limit = 20) => {
-        return apiFetch(`${base}/sessions/${encodeURIComponent(name)}/messages?limit=${limit}`, password);
-    }, [base, password]);
-    const injectText = useCallback(async (name, text) => {
-        return apiFetch(`${base}/sessions/${encodeURIComponent(name)}/inject`, password, { method: "POST", body: JSON.stringify({ text }) });
-    }, [base, password]);
-    const revertToStart = useCallback(async (name) => {
-        return apiFetch(`${base}/sessions/${encodeURIComponent(name)}/revert-to-start`, password, { method: "POST" });
-    }, [base, password]);
-    const revertAll = useCallback(async () => {
-        return apiFetch(`${base}/sessions/revert-all`, password, { method: "POST" });
-    }, [base, password]);
-    const regenerateCode = useCallback(async (name) => {
-        return apiFetch(`${base}/sessions/${encodeURIComponent(name)}/regenerate-code`, password, { method: "POST" });
-    }, [base, password]);
-    const getConfig = useCallback(async () => {
-        return apiFetch(`${base}/config`, password);
-    }, [base, password]);
-    const setConfig = useCallback(async (key, value) => {
-        return apiFetch(`${base}/config`, password, { method: "PUT", body: JSON.stringify({ key, value }) });
-    }, [base, password]);
-    const getMailMessages = useCallback(async (name, options) => {
-        const params = new URLSearchParams();
-        if (options?.sent)
-            params.set("sent", "true");
-        if (options?.unreadOnly)
-            params.set("unread_only", "true");
-        const query = params.toString() ? `?${params.toString()}` : "";
-        return apiFetch(`${base}/messages/${encodeURIComponent(name)}${query}`, password);
-    }, [base, password]);
-    const sendMailMessage = useCallback(async (from, to, body) => {
-        return apiFetch(`${base}/messages`, password, { method: "POST", body: JSON.stringify({ from, to, body }) });
-    }, [base, password]);
-    const markMessageRead = useCallback(async (id) => {
-        return apiFetch(`${base}/messages/${id}/read`, password, { method: "POST" });
-    }, [base, password]);
-    const listCrons = useCallback(async (sessionName) => {
-        const params = sessionName ? `?session_name=${encodeURIComponent(sessionName)}` : "";
-        return apiFetch(`${base}/crons${params}`, password);
-    }, [base, password]);
-    const createCron = useCallback(async (data) => {
-        return apiFetch(`${base}/crons`, password, {
-            method: "POST",
-            body: JSON.stringify(data),
-        });
-    }, [base, password]);
-    const deleteCron = useCallback(async (id) => {
-        return apiFetch(`${base}/crons/${id}`, password, { method: "DELETE" });
-    }, [base, password]);
-    const enableCron = useCallback(async (id) => {
-        return apiFetch(`${base}/crons/${id}/enable`, password, { method: "POST" });
-    }, [base, password]);
-    const disableCron = useCallback(async (id) => {
-        return apiFetch(`${base}/crons/${id}/disable`, password, { method: "POST" });
-    }, [base, password]);
-    const getCronHistory = useCallback(async (id, limit = 10) => {
-        return apiFetch(`${base}/crons/${id}/history?limit=${limit}`, password);
-    }, [base, password]);
-    const listCronRequests = useCallback(async (filters) => {
-        const params = new URLSearchParams();
-        if (filters?.status)
-            params.set("status", filters.status);
-        if (filters?.sessionName)
-            params.set("session_name", filters.sessionName);
-        const query = params.toString() ? `?${params.toString()}` : "";
-        return apiFetch(`${base}/cron-requests${query}`, password);
-    }, [base, password]);
-    const approveCronRequest = useCallback(async (id, notes) => {
-        return apiFetch(`${base}/cron-requests/${id}/approve`, password, { method: "POST", body: JSON.stringify({ notes }) });
-    }, [base, password]);
-    const rejectCronRequest = useCallback(async (id, notes) => {
-        return apiFetch(`${base}/cron-requests/${id}/reject`, password, { method: "POST", body: JSON.stringify({ notes }) });
-    }, [base, password]);
-    return {
-        listSessions,
-        createSession,
-        deleteSession,
-        updateSessionAgent,
-        checkHealth,
-        getMessages,
-        injectText,
-        revertToStart,
-        revertAll,
-        regenerateCode,
-        getConfig,
-        setConfig,
-        getMailMessages,
-        sendMailMessage,
-        markMessageRead,
-        getModes,
-        listCrons,
-        createCron,
-        deleteCron,
-        enableCron,
-        disableCron,
-        getCronHistory,
-        listCronRequests,
-        approveCronRequest,
-        rejectCronRequest,
-    };
-}
-export function useAsyncState() {
-    const [state, setState] = useState({
-        data: null,
-        loading: false,
-        error: null,
-    });
-    const run = useCallback(async (fn) => {
-        setState({ data: null, loading: true, error: null });
-        try {
-            const data = await fn();
-            setState({ data, loading: false, error: null });
-            return data;
-        }
-        catch (err) {
-            const error = err instanceof Error ? err.message : String(err);
-            setState({ data: null, loading: false, error });
-            return null;
-        }
-    }, []);
-    return { ...state, run };
-}

package/dist/server/cron.d.ts

@@ -1,25 +0,0 @@
-import type { AgentOfficeStorage } from "../db/storage.js";
-import type { AgenticCodingServer } from "../lib/agentic-coding-server.js";
-import type { CronJobRow } from "../db/index.js";
-interface CronSchedulerOptions {
-    onJobExecuted?: (jobId: number, success: boolean, error?: string) => void;
-}
-export declare class CronScheduler {
-    private options;
-    private activeJobs;
-    private storage;
-    private agenticCodingServer;
-    private serverUrl;
-    private started;
-    constructor(options?: CronSchedulerOptions);
-    start(storage: AgentOfficeStorage, agenticCodingServer: AgenticCodingServer, serverUrl: string): Promise<void>;
-    stop(): void;
-    private addJob;
-    private executeJob;
-    addCronJob(job: CronJobRow): void;
-    removeCronJob(jobId: number): void;
-    enableCronJob(job: CronJobRow): void;
-    disableCronJob(jobId: number): void;
-    isTracking(jobId: number): boolean;
-}
-export {};

package/dist/server/cron.js

@@ -1,107 +0,0 @@
-import { Cron } from "croner";
-import { generateSystemPrompt } from "./routes.js";
-const CRON_INJECTION_BLURB = [
-    ``,
-    `---`,
-    `You have a scheduled cron job trigger. Please review the injected message above`,
-    `and take appropriate action.`,
-].join("\n");
-export class CronScheduler {
-    options;
-    activeJobs = new Map();
-    storage = null;
-    agenticCodingServer = null;
-    serverUrl = "";
-    started = false;
-    constructor(options = {}) {
-        this.options = options;
-    }
-    async start(storage, agenticCodingServer, serverUrl) {
-        if (this.started)
-            return;
-        this.storage = storage;
-        this.agenticCodingServer = agenticCodingServer;
-        this.serverUrl = serverUrl;
-        const rows = await storage.listCronJobs();
-        for (const job of rows) {
-            if (job.enabled) {
-                this.addJob(job);
-            }
-        }
-        this.started = true;
-        console.log(`Cron scheduler started: tracking ${rows.length} active jobs`);
-    }
-    stop() {
-        for (const cronInst of this.activeJobs.values()) {
-            cronInst.cron.stop();
-        }
-        this.activeJobs.clear();
-        this.started = false;
-        console.log("Cron scheduler stopped");
-    }
-    addJob(job) {
-        if (!this.agenticCodingServer || !this.storage)
-            return;
-        const options = {
-            protect: true,
-            name: job.name,
-        };
-        if (job.timezone) {
-            options.timezone = job.timezone;
-        }
-        const cron = new Cron(job.schedule, options, async () => {
-            await this.executeJob(job);
-        });
-        this.activeJobs.set(job.id, { cron, job });
-    }
-    async executeJob(job) {
-        if (!this.storage || !this.agenticCodingServer)
-            return;
-        const executedAt = new Date();
-        try {
-            const session = await this.storage.getSessionByName(job.session_name);
-            if (!session) {
-                throw new Error(`Session "${job.session_name}" not found`);
-            }
-            const humanName = (await this.storage.getConfig('human_name')) ?? 'your human manager';
-            const humanDescription = (await this.storage.getConfig('human_description')) ?? '';
-            const injectText = `[Cron Job "${job.name}" — ${executedAt.toISOString()}]\n${job.message}${CRON_INJECTION_BLURB}`;
-            const token = `${session.agent_code}@${this.serverUrl}`;
-            const system = generateSystemPrompt(job.session_name, session.status, humanName, humanDescription, token);
-            await this.agenticCodingServer.sendMessage(session.session_id, injectText, session.agent, system);
-            await this.storage.updateCronJobLastRun(job.id, executedAt);
-            await this.storage.createCronHistory(job.id, executedAt, true);
-            this.options.onJobExecuted?.(job.id, true);
-            console.log(`Cron job "${job.name}" executed successfully`);
-        }
-        catch (err) {
-            const errorMessage = err instanceof Error ? err.message : String(err);
-            await this.storage.createCronHistory(job.id, executedAt, false, errorMessage);
-            this.options.onJobExecuted?.(job.id, false, errorMessage);
-            console.error(`Cron job "${job.name}" failed:`, errorMessage);
-        }
-    }
-    addCronJob(job) {
-        if (job.enabled) {
-            this.addJob(job);
-        }
-    }
-    removeCronJob(jobId) {
-        const cronInst = this.activeJobs.get(jobId);
-        if (cronInst) {
-            cronInst.cron.stop();
-            this.activeJobs.delete(jobId);
-        }
-    }
-    enableCronJob(job) {
-        if (!this.activeJobs.has(job.id) && job.enabled) {
-            this.addJob(job);
-        }
-    }
-    disableCronJob(jobId) {
-        this.removeCronJob(jobId);
-    }
-    isTracking(jobId) {
-        return this.activeJobs.has(jobId);
-    }
-}

package/dist/server/index.d.ts

@@ -1,4 +0,0 @@
-import type { AgentOfficeStorage } from "../db/index.js";
-import type { AgenticCodingServer } from "../lib/agentic-coding-server.js";
-import { CronScheduler } from "./cron.js";
-export declare function createApp(storage: AgentOfficeStorage, agenticCodingServer: AgenticCodingServer, password: string, serverUrl: string, cronScheduler: CronScheduler): import("express-serve-static-core").Express;

package/dist/server/index.js

@@ -1,22 +0,0 @@
-import express from "express";
-import { createRouter, createWorkerRouter } from "./routes.js";
-function authMiddleware(password) {
-    return (req, res, next) => {
-        const header = req.headers.authorization;
-        if (!header || header !== `Bearer ${password}`) {
-            res.status(401).json({ error: "Unauthorized" });
-            return;
-        }
-        next();
-    };
-}
-export function createApp(storage, agenticCodingServer, password, serverUrl, cronScheduler) {
-    const app = express();
-    app.use(express.json());
-    // Worker routes are unauthenticated — mounted before auth middleware
-    app.use("/", createWorkerRouter(storage, agenticCodingServer, serverUrl));
-    // Everything else requires Bearer auth
-    app.use(authMiddleware(password));
-    app.use("/", createRouter(storage, agenticCodingServer, serverUrl, cronScheduler));
-    return app;
-}

package/dist/server/routes.d.ts

@@ -1,13 +0,0 @@
-import { Router } from "express";
-import type { AgentOfficeStorage } from "../db/index.js";
-import type { AgenticCodingServer } from "../lib/agentic-coding-server.js";
-import { CronScheduler } from "./cron.js";
-/**
- * Build the persistent system-prompt briefing for a worker session.
- * This is injected as the `system` field on every `promptAsync` call so the
- * agent always has its identity, token, and command reference in context —
- * without consuming a user-message turn.
- */
-export declare function generateSystemPrompt(name: string, status: string | null, humanName: string, humanDescription: string, token: string): string;
-export declare function createRouter(storage: AgentOfficeStorage, agenticCodingServer: AgenticCodingServer, serverUrl: string, scheduler: CronScheduler): Router;
-export declare function createWorkerRouter(storage: AgentOfficeStorage, agenticCodingServer: AgenticCodingServer, serverUrl: string): Router;