@andorra-labs/code 0.0.0-stage → 0.1.4

package/dist/src/automation-service.js

@@ -0,0 +1,299 @@
+import { spawn, execFile } from 'node:child_process';
+import { createServer } from 'node:http';
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdir, readFile, writeFile, unlink } from 'node:fs/promises';
+import { basename, dirname, join, resolve, win32 } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { promisify } from 'node:util';
+import { setTimeout as delay } from 'node:timers/promises';
+import { configDirectory } from './config.js';
+import { acquireSaveLock, SaveLockBusyError } from './save-lock.js';
+import { AutomationStore } from './automations.js';
+import { executeAutomation } from './automation-runner.js';
+const exec = promisify(execFile);
+const serviceFolder = (directory) => join(directory, 'automation-service');
+const taskName = (directory) => 'Andorra Automations ' + createHash('sha256').update(resolve(directory).toLowerCase()).digest('hex').slice(0, 12);
+const cliFile = () => fileURLToPath(new URL('./cli.js', import.meta.url));
+async function owner(directory) {
+    try {
+        const value = JSON.parse(await readFile(join(serviceFolder(directory), 'owner.json'), 'utf8'));
+        if (Number.isSafeInteger(value.pid) && value.pid > 0 && Number.isInteger(value.port) && value.port > 0 && value.port < 65536 && typeof value.token === 'string' && /^[a-f0-9-]{36}$/.test(value.token))
+            return value;
+    }
+    catch { /* no reachable service is a normal stopped state */ }
+    return undefined;
+}
+async function contact(directory, action) {
+    const record = await owner(directory);
+    if (!record)
+        return;
+    try {
+        const response = await fetch(`http://127.0.0.1:${record.port}/${action}`, { method: 'POST', headers: { authorization: `Bearer ${record.token}` }, signal: AbortSignal.timeout(2_000) });
+        if (!response.ok)
+            return;
+        const result = await response.json();
+        if (result.pid === record.pid && result.token === record.token)
+            return record;
+    }
+    catch { /* stale metadata never grants authority to kill a reused PID */ }
+    return undefined;
+}
+/** Scheduler hot path: probe the owner without spawning Task Scheduler's registration query. */
+export async function automationServiceRunning(directory = configDirectory()) {
+    return !!await contact(directory, 'status');
+}
+async function installed(directory) {
+    if (process.platform !== 'win32')
+        return false;
+    try {
+        await exec('schtasks.exe', ['/Query', '/TN', taskName(directory)], { windowsHide: true, timeout: 10_000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function status(directory) {
+    const live = await contact(directory, 'status');
+    const registered = await installed(directory);
+    return { running: !!live, installed: registered, installSupported: process.platform === 'win32', ...(live ? { pid: live.pid } : {}),
+        detail: live ? 'Background scheduler is running. The computer must stay awake and signed in.' : registered ? 'Start at sign-in is installed; the background scheduler is stopped.' : 'Background scheduler is stopped. App-open schedules still run while Andorra is open.' };
+}
+/** Authenticated loopback control avoids signalling an unrelated process after PID reuse. */
+export async function runAutomationDaemon(directory = configDirectory(), externalSignal) {
+    directory = resolve(directory);
+    const folder = serviceFolder(directory);
+    await mkdir(folder, { recursive: true });
+    let release;
+    try {
+        release = await acquireSaveLock(folder);
+    }
+    catch (error) {
+        if (error instanceof SaveLockBusyError)
+            return;
+        throw error;
+    }
+    const controller = new AbortController();
+    const abort = () => controller.abort();
+    externalSignal?.addEventListener('abort', abort, { once: true });
+    process.once('SIGTERM', abort);
+    process.once('SIGINT', abort);
+    if (externalSignal?.aborted)
+        abort();
+    const token = randomUUID();
+    const passes = new Set();
+    const server = createServer((request, response) => {
+        if (request.method !== 'POST' || request.headers.authorization !== `Bearer ${token}` || !['/status', '/stop'].includes(request.url ?? '')) {
+            response.writeHead(403).end();
+            return;
+        }
+        response.setHeader('content-type', 'application/json');
+        response.end(JSON.stringify({ pid: process.pid, token }));
+        if (request.url === '/stop')
+            controller.abort();
+    });
+    try {
+        await new Promise((resolveReady, reject) => { server.once('error', reject); server.listen(0, '127.0.0.1', resolveReady); });
+        const address = server.address();
+        if (!address || typeof address === 'string')
+            throw new Error('Background scheduler failed to bind loopback.');
+        await writeFile(join(folder, 'owner.json'), JSON.stringify({ pid: process.pid, token, port: address.port }), { mode: 0o600 });
+        const store = new AutomationStore(directory);
+        while (!controller.signal.aborted) {
+            if (passes.size < 4) {
+                const pass = store.tick((job, signal) => executeAutomation(job, signal, directory), controller.signal).catch(error => {
+                    if (!controller.signal.aborted)
+                        process.stderr.write(`Automation scheduler: ${String(error)}\n`);
+                });
+                passes.add(pass);
+                void pass.finally(() => passes.delete(pass));
+            }
+            await delay(5_000, undefined, { signal: controller.signal }).catch(() => { });
+        }
+    }
+    finally {
+        controller.abort();
+        await Promise.allSettled(passes);
+        await new Promise(done => server.close(() => done()));
+        if ((await owner(directory))?.token === token)
+            await unlink(join(folder, 'owner.json')).catch(() => { });
+        process.removeListener('SIGTERM', abort);
+        process.removeListener('SIGINT', abort);
+        externalSignal?.removeEventListener('abort', abort);
+        await release();
+    }
+}
+const xml = (text) => text.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;').replaceAll('"', '&quot;').replaceAll("'", '&apos;');
+/** Standard Windows argv quoting, used inside Task Scheduler's Arguments XML field. */
+export const windowsArgument = (value) => '"' + value.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\+)$/, '$1$1') + '"';
+export function automationTaskXml(directory, user) {
+    const args = [cliFile(), 'automations', 'serve', '--home', resolve(directory)].map(windowsArgument).join(' ');
+    return `<?xml version="1.0" encoding="UTF-16"?><Task version="1.2" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task"><RegistrationInfo><Description>Run saved Andorra automations while signed in.</Description></RegistrationInfo><Triggers><LogonTrigger><Enabled>true</Enabled><UserId>${xml(user)}</UserId></LogonTrigger></Triggers><Principals><Principal id="Author"><UserId>${xml(user)}</UserId><LogonType>InteractiveToken</LogonType><RunLevel>LeastPrivilege</RunLevel></Principal></Principals><Settings><MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy><DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries><StopIfGoingOnBatteries>false</StopIfGoingOnBatteries><ExecutionTimeLimit>PT0S</ExecutionTimeLimit><Enabled>true</Enabled></Settings><Actions Context="Author"><Exec><Command>${xml(process.execPath)}</Command><Arguments>${xml(args)}</Arguments></Exec></Actions></Task>`;
+}
+const unxml = (text) => text.replace(/&(?:amp|lt|gt|quot|apos);/g, entity => ({ '&amp;': '&', '&lt;': '<', '&gt;': '>', '&quot;': '"', '&apos;': "'" })[entity]);
+const windowsPath = (path) => win32.normalize(path.replace(/^\\\\\?\\/, '')).toLowerCase();
+/** Retarget only our exact managed-bundle action; preserve account, triggers and disabled state. */
+export function upgradedAutomationTaskXml(task, directory, node, cli) {
+    const commands = [...task.matchAll(/<Command>([^<]*)<\/Command>/g)];
+    const argumentsFields = [...task.matchAll(/<Arguments>([^<]*)<\/Arguments>/g)];
+    if (commands.length !== 1 || argumentsFields.length !== 1)
+        return;
+    const oldNode = unxml(commands[0][1]);
+    const oldRoot = win32.dirname(oldNode), newRoot = win32.dirname(node);
+    if (windowsPath(oldNode) === windowsPath(node)
+        || win32.basename(oldNode).toLowerCase() !== 'node.exe'
+        || windowsPath(win32.dirname(oldRoot)) !== windowsPath(win32.dirname(newRoot)))
+        return;
+    const oldArgs = [win32.join(oldRoot, 'dist', 'src', 'cli.js'), 'automations', 'serve', '--home', resolve(directory)].map(windowsArgument).join(' ');
+    // Compare complete arguments, not a substring that could also name a custom command/home.
+    const comparableArgs = (value) => value.replaceAll('\\\\?\\', '').toLowerCase();
+    if (comparableArgs(unxml(argumentsFields[0][1])) !== comparableArgs(oldArgs))
+        return;
+    const args = [cli, 'automations', 'serve', '--home', resolve(directory)].map(windowsArgument).join(' ');
+    return task.replace(commands[0][0], `<Command>${xml(node)}</Command>`)
+        .replace(argumentsFields[0][0], `<Arguments>${xml(args)}</Arguments>`);
+}
+/** A GUI upgrade must also advance an existing sign-in task, without installing one implicitly. */
+export async function reconcileAutomationService(directory = configDirectory(), host = {
+    platform: process.platform,
+    managed: process.env.ANDORRA_MANAGED_DESKTOP_ENGINE === '1',
+    node: process.execPath,
+    cli: cliFile(),
+    run: async (args) => (await exec('schtasks.exe', args, { windowsHide: true, timeout: 20_000, encoding: 'buffer' })).stdout,
+}) {
+    if (host.platform !== 'win32' || !host.managed)
+        return;
+    const cli = host.cli, root = resolve(dirname(cli), '..', '..');
+    if (basename(dirname(root)) !== 'engine')
+        return;
+    let bundle;
+    try {
+        bundle = JSON.parse(await readFile(join(root, 'bundle.json'), 'utf8'));
+    }
+    catch {
+        return;
+    } // Source/global/custom engines do not manage the desktop's registration.
+    if (bundle.platform !== 'win32' || bundle.version !== basename(root))
+        return;
+    const node = join(root, 'node.exe');
+    if (windowsPath(host.node) !== windowsPath(node))
+        return; // Explicit Node overrides remain user-managed.
+    let task;
+    try {
+        const output = await host.run(['/Query', '/TN', taskName(directory), '/XML']);
+        // Task Scheduler can emit UTF-16 XML when stdout is redirected to a pipe.
+        task = output.toString(output.includes(0) ? 'utf16le' : 'utf8').replace(/^\ufeff/, '');
+    }
+    catch {
+        return;
+    } // A user who never enabled start at sign-in stays opted out.
+    const updated = upgradedAutomationTaskXml(task, directory, node, cli);
+    if (!updated)
+        return;
+    const folder = serviceFolder(directory);
+    await mkdir(folder, { recursive: true });
+    const path = join(folder, `task-${randomUUID()}.xml`);
+    try {
+        await writeFile(path, '\ufeff' + updated, { encoding: 'utf16le', mode: 0o600 });
+        await host.run(['/Create', '/TN', taskName(directory), '/XML', path, '/F']);
+    }
+    finally {
+        await unlink(path).catch(() => { });
+    }
+}
+export async function automationService(action, directory = configDirectory()) {
+    directory = resolve(directory);
+    if (action === 'status')
+        return status(directory);
+    if (action === 'install') {
+        if (process.platform !== 'win32')
+            throw new Error('Start at sign-in installation is currently supported on Windows. Use background Start on this platform.');
+        const folder = serviceFolder(directory);
+        await mkdir(folder, { recursive: true });
+        const user = (await exec('whoami.exe', [], { windowsHide: true, timeout: 10_000 })).stdout.trim();
+        const path = join(folder, `task-${randomUUID()}.xml`);
+        try {
+            await writeFile(path, '\ufeff' + automationTaskXml(directory, user), { encoding: 'utf16le', mode: 0o600 });
+            await exec('schtasks.exe', ['/Create', '/TN', taskName(directory), '/XML', path, '/F'], { windowsHide: true, timeout: 20_000 });
+        }
+        finally {
+            await unlink(path).catch(() => { });
+        }
+        return automationService('start', directory);
+    }
+    if (action === 'uninstall') {
+        if (process.platform !== 'win32')
+            throw new Error('Start at sign-in installation is currently supported on Windows.');
+        if (await installed(directory))
+            await exec('schtasks.exe', ['/Delete', '/TN', taskName(directory), '/F'], { windowsHide: true, timeout: 20_000 });
+        return automationService('stop', directory);
+    }
+    if (action === 'stop') {
+        const live = await contact(directory, 'stop');
+        if (live) {
+            for (let i = 0; i < 80; i++) {
+                if (!await contact(directory, 'status'))
+                    return status(directory);
+                await delay(250);
+            }
+            throw new Error('Background scheduler is still stopping. Check status again.');
+        }
+        return status(directory);
+    }
+    if (!await contact(directory, 'status')) {
+        const folder = serviceFolder(directory);
+        await mkdir(folder, { recursive: true });
+        const child = spawn(process.execPath, [cliFile(), 'automations', 'serve', '--home', directory], {
+            detached: true, stdio: 'ignore', windowsHide: true,
+            env: { ...process.env, ANDORRACODE_HOME: directory },
+        });
+        let startupError;
+        child.once('error', error => { startupError = error; });
+        child.unref();
+        for (let i = 0; i < 120; i++) {
+            if (startupError)
+                throw startupError;
+            if (await contact(directory, 'status'))
+                return status(directory);
+            await delay(250);
+        }
+        throw new Error('Background scheduler did not start within 30 seconds.');
+    }
+    return status(directory);
+}
+export async function runAutomationCommand(args, print) {
+    if (!args.length || args.includes('--help') || args.includes('-h')) {
+        print('Usage: andorra automations list | run <id> | service status|start|stop|install|uninstall | serve [--home <directory>]');
+        return 0;
+    }
+    if (args[0] === 'serve') {
+        if (!(args.length === 1 || (args.length === 3 && args[1] === '--home')))
+            throw new Error('Usage: andorra automations serve [--home <directory>]');
+        await runAutomationDaemon(args[2] ?? configDirectory());
+        return 0;
+    }
+    if (args[0] === 'service' && args.length === 2 && ['status', 'start', 'stop', 'install', 'uninstall'].includes(args[1])) {
+        print(JSON.stringify(await automationService(args[1])));
+        return 0;
+    }
+    const store = new AutomationStore();
+    if (args[0] === 'list' && args.length === 1) {
+        print(JSON.stringify({ automations: await store.list() }));
+        return 0;
+    }
+    if (args[0] === 'run' && args.length === 2) {
+        const controller = new AbortController();
+        const abort = () => controller.abort();
+        process.once('SIGINT', abort);
+        process.once('SIGTERM', abort);
+        try {
+            print(JSON.stringify(await store.runNow(args[1], executeAutomation, controller.signal)));
+        }
+        finally {
+            process.removeListener('SIGINT', abort);
+            process.removeListener('SIGTERM', abort);
+        }
+        return 0;
+    }
+    throw new Error('Usage: andorra automations list | run <id> | service status|start|stop|install|uninstall | serve [--home <directory>]');
+}

package/dist/src/automation-tool.d.ts

@@ -0,0 +1,2 @@
+import type { Tool } from './types.js';
+export declare function createAutomationTool(): Tool;

package/dist/src/automation-tool.js

@@ -0,0 +1,49 @@
+import { AutomationStore } from './automations.js';
+import { approveOperation } from './capabilities.js';
+import { permissionMode } from './permissions.js';
+export function createAutomationTool() {
+    return {
+        name: 'automations', capability: 'external', executionMode: 'sequential',
+        description: 'Manage durable scheduled jobs shown in the desktop Automations page. Create a fresh session in the chosen local project with a saved prompt at each five-field CRON or daily HH:mm local-time schedule (IANA timeZone required). Unlike set_timer, these jobs persist across restarts and start NEW sessions; use set_timer to continue this conversation once. Jobs run while Andorra is open or while the user-enabled background service runs; missed occurrences are skipped and a job never overlaps itself. Call list to inspect jobs, create/update to configure them, delete to remove, or run to start one now. Unattended runs cannot answer approval prompts or user questions. Creating or changing future work requires permission; never increase saved execution permissions beyond the current run.',
+        parameters: { type: 'object', additionalProperties: false, properties: {
+                action: { type: 'string', enum: ['list', 'create', 'update', 'delete', 'run'] },
+                id: { type: 'string', description: 'Existing job ID for update/delete/run' },
+                name: { type: 'string' }, project: { type: 'string', description: 'Absolute local project directory; defaults to this workspace when creating' }, prompt: { type: 'string' },
+                schedule: { type: 'object', additionalProperties: false, properties: { kind: { type: 'string', enum: ['cron', 'daily'] }, expression: { type: 'string' }, time: { type: 'string' }, timeZone: { type: 'string' } }, required: ['kind', 'timeZone'] },
+                enabled: { type: 'boolean' },
+            }, required: ['action'] },
+        execute: async (args, context) => {
+            context.signal.throwIfAborted();
+            const allowed = ['action', 'id', 'name', 'project', 'prompt', 'schedule', 'enabled'];
+            if (Object.keys(args).some(key => !allowed.includes(key)))
+                throw new Error('Unknown automation argument');
+            const store = new AutomationStore(context.automationDirectory);
+            if (args.action === 'list')
+                return JSON.stringify({ automations: await store.list() });
+            if (!['create', 'update', 'delete', 'run'].includes(String(args.action)))
+                throw new Error('Choose list, create, update, delete or run');
+            await approveOperation(context, 'automations', { ...args, warning: 'This changes durable future work or starts an unattended session.' });
+            context.signal.throwIfAborted();
+            const id = args.id;
+            if (args.action !== 'create' && (typeof id !== 'string' || !id))
+                throw new Error('id is required');
+            if (args.action === 'delete') {
+                await store.delete(id);
+                return JSON.stringify({ ok: true });
+            }
+            if (args.action === 'run') {
+                const { executeAutomation } = await import('./automation-runner.js');
+                return JSON.stringify({ automation: await store.runNow(id, (job, signal) => executeAutomation(job, signal, context.automationDirectory), context.signal, permissionMode(context) ?? 'ask-for-approval') });
+            }
+            const { action: _action, id: _id, ...input } = args;
+            if (args.action === 'create') {
+                input.project ??= context.workspace;
+                input.execution = { ...context.wakeCarry, permissions: permissionMode(context) ?? 'ask-for-approval' };
+                // Only execution selections have meaning on a new session: omit wake-only input/state scope.
+                input.execution = Object.fromEntries(Object.entries(input.execution).filter(([key]) => ['provider', 'model', 'graph', 'permissions', 'reasoningEffort'].includes(key)));
+                return JSON.stringify({ automation: await store.create(input, 'agent') });
+            }
+            return JSON.stringify({ automation: await store.update(id, input, permissionMode(context) ?? 'ask-for-approval') });
+        },
+    };
+}

package/dist/src/automation-worker-shutdown.d.ts

@@ -0,0 +1,3 @@
+import type { ChildProcess } from 'node:child_process';
+/** EOF grants normal cleanup; a process that outlives the grace period must be reaped. */
+export declare function stopAutomationWorker(child: ChildProcess, closed: Promise<void>, graceMs?: number): Promise<void>;

package/dist/src/automation-worker-shutdown.js

@@ -0,0 +1,13 @@
+/** EOF grants normal cleanup; a process that outlives the grace period must be reaped. */
+export async function stopAutomationWorker(child, closed, graceMs = 10_000) {
+    child.stdin?.end();
+    // App-server handles SIGTERM on POSIX, so repeating it cannot guarantee stalled cleanup ends.
+    // Windows' existing kill behavior is already unconditional termination.
+    const force = setTimeout(() => child.kill(process.platform === 'win32' ? undefined : 'SIGKILL'), graceMs);
+    try {
+        await closed;
+    }
+    finally {
+        clearTimeout(force);
+    }
+}

package/dist/src/automations.d.ts

@@ -0,0 +1,63 @@
+import { type PermissionMode } from './permissions.js';
+export type AutomationSchedule = {
+    kind: 'cron';
+    expression: string;
+    timeZone: string;
+} | {
+    kind: 'daily';
+    time: string;
+    timeZone: string;
+};
+export interface AutomationExecution {
+    provider?: string;
+    model?: string;
+    graph?: string;
+    permissions?: PermissionMode;
+    reasoningEffort?: string;
+}
+export interface Automation {
+    id: string;
+    name: string;
+    project: string;
+    prompt: string;
+    schedule: AutomationSchedule;
+    enabled: boolean;
+    source: 'user' | 'agent';
+    execution?: AutomationExecution;
+    createdAt: string;
+    updatedAt: string;
+    nextRunAt: string;
+    lastRun?: {
+        at: string;
+        status: 'running' | 'completed' | 'failed' | 'interrupted' | 'skipped';
+        sessionId?: string;
+        runId?: string;
+        error?: string;
+    };
+}
+export type AutomationExecutor = (job: Automation, signal: AbortSignal) => Promise<{
+    sessionId?: string;
+    runId?: string;
+}>;
+export declare function validateAutomationSchedule(value: unknown): AutomationSchedule;
+export declare function nextAutomationRun(schedule: AutomationSchedule, after?: number): string;
+/** One installation-wide store, shared by desktop engines, agent tools and the optional daemon. */
+export declare class AutomationStore {
+    readonly folder: string;
+    constructor(directory?: string);
+    private read;
+    private mutate;
+    list(): Promise<Automation[]>;
+    private input;
+    create(value: Record<string, unknown>, source?: Automation['source']): Promise<Automation>;
+    update(id: string, value: Record<string, unknown>, maxPermissions?: PermissionMode): Promise<Automation>;
+    delete(id: string): Promise<void>;
+    runNow(id: string, executor: AutomationExecutor, signal?: AbortSignal, maxPermissions?: PermissionMode): Promise<Automation>;
+    startNow(id: string, executor: AutomationExecutor, signal?: AbortSignal, maxPermissions?: PermissionMode): Promise<{
+        automation: Automation;
+        completion: Promise<void>;
+    }>;
+    private claim;
+    private execute;
+    tick(executor: AutomationExecutor, signal?: AbortSignal, now?: number): Promise<void>;
+}