@agentorg/cli 0.0.5 → 0.0.7

package/dist/node_modules/@agentorg/computer-connector/dist/src/provider.js

@@ -0,0 +1,482 @@
+// The units' provider, and the connector to AgentComputer. A computer is one the service runs: this
+// asks the service for it through its SDK, then opens an ordinary `url` connection to each endpoint
+// with the computer's token. The web unit is one connection to a hosted server. Nothing here starts
+// a service. The control token and each computer's token stay in this provider's private file.
+import { randomBytes } from "node:crypto";
+import { chmodSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { isAbsolute, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Computer, ComputerError } from "@agentorg/computer";
+import { hubActors, unitProvider } from "@agentorg/interfaces";
+import { Connection, parseConnection } from "@agentorg/mcp";
+import { Refused } from "@agentorg/sdk";
+import { connect } from "@agentorg/sdk/client";
+import { z } from "zod";
+import { ANOTHER, BROWSER_SLOT, COMPUTER, computerUnit, INSTALL_STEPS, LOCAL, SKILLS, WEB, WEB_UNIT, } from "./unit.js";
+const Link = z.object({
+    slot: z.string(),
+    actor: z.string(),
+    credential: z.string(),
+    url: z.string(),
+});
+const Stored = z.object({
+    agent: z.string(),
+    links: z.array(Link),
+    /** The computer behind them. A service at an address is reached with what is kept here. */
+    computer: z
+        .object({
+        id: z.string(),
+        token: z.string(),
+        service: z.union([
+            z.object({ local: z.literal(true) }),
+            z.object({ apiUrl: z.string(), apiKey: z.string() }),
+        ]),
+    })
+        .optional(),
+});
+const FILE = "instances.json";
+const SKILLS_DIR = fileURLToPath(new URL("../../skills/", import.meta.url));
+const EXA_URL = "https://mcp.exa.ai/mcp?tools=web_search_exa,web_fetch_exa";
+const SERVICE_ANSWERS_MS = 2000;
+const SAYS = {
+    read: "reads files",
+    files: "reads and changes files",
+    terminal: "files and terminal",
+};
+const LEVELS = ["read", "files", "terminal"];
+const messageOf = (error) => (error instanceof Error ? error.message : String(error));
+const quiet = { info() { }, warn() { }, error() { } };
+/** An endpoint at the address the service was reached on, whatever the service calls itself. */
+const at = (apiUrl, endpoint) => {
+    const url = new URL(endpoint);
+    const { origin } = new URL(apiUrl);
+    return `${origin}${url.pathname}${url.search}`;
+};
+/** A live session's socket, at the address the service was reached on. */
+const socketAt = (apiUrl, socket) => {
+    const { pathname, search } = new URL(socket);
+    const reached = new URL(apiUrl);
+    return `${reached.protocol === "https:" ? "wss:" : "ws:"}//${reached.host}${pathname}${search}`;
+};
+/** How long a computer's own surfaces may take to say what they are, in a status. */
+const SURFACES_MS = 2000;
+/** How long what they said is used again: a status is asked for often. */
+const SURFACES_FRESH_MS = 10_000;
+/** The same folders the service looks in itself. */
+const defaultDataFolder = () => process.env.AGENTCOMPUTER_DATA ??
+    (process.env.XDG_DATA_HOME
+        ? join(process.env.XDG_DATA_HOME, "agentcomputer")
+        : join(homedir(), ".local", "share", "agentcomputer"));
+/** A folder as a person writes it: `~/` is their home. */
+const fromHome = (folder) => typeof folder === "string" && folder.startsWith("~/")
+    ? join(homedir(), folder.slice(2))
+    : folder;
+/** What is wrong with what was filled in; nothing means it can be applied. */
+function problems(unit, values, found, secrets) {
+    const wrong = [];
+    if (unit === WEB) {
+        if (values.service !== "exa")
+            wrong.push({ field: "service", message: "Choose a service." });
+        return wrong;
+    }
+    if ((values.service === LOCAL || values.service === undefined) && !found)
+        wrong.push({ field: "service", message: INSTALL_STEPS });
+    else if (values.service === ANOTHER) {
+        const given = secrets.includes("token") ? { token: "given" } : {};
+        const { why } = parseConnection("url", { url: values.address }, given);
+        if (why)
+            wrong.push({ field: "address", message: `That address won't do. ${why}` });
+    }
+    else if (values.service !== LOCAL)
+        wrong.push({ field: "service", message: "Choose a service." });
+    if (values.access === "none") {
+        if (values.browser !== true)
+            wrong.push({
+                field: "access",
+                message: "With no files, no commands and no browser, there's no computer.",
+            });
+    }
+    else if (!LEVELS.includes(values.access))
+        wrong.push({ field: "access", message: "Choose what it can do." });
+    const workspace = fromHome(values.workspace);
+    if (values.service === LOCAL && workspace !== undefined) {
+        let folder = false;
+        try {
+            folder = isAbsolute(workspace) && statSync(workspace).isDirectory();
+        }
+        catch {
+            // Reported as not being a folder.
+        }
+        if (!folder)
+            wrong.push({ field: "workspace", message: `There's no folder at ${workspace}.` });
+    }
+    return wrong;
+}
+/** Run the units' provider as an Actor exporting `unit.provider@1` as `provider`. */
+export async function startComputerProvider(options) {
+    const log = options.log ?? quiet;
+    const { hubUrl, dir } = options;
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    chmodSync(dir, 0o700);
+    const path = join(dir, FILE);
+    const read = () => {
+        let raw;
+        try {
+            raw = readFileSync(path, "utf8");
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return {};
+            throw error;
+        }
+        try {
+            return z.record(z.string(), Stored).parse(JSON.parse(raw));
+        }
+        catch {
+            renameSync(path, `${path}.unreadable-${Date.now()}`);
+            log.error("The computers file can't be read: it is set aside and starts empty.");
+            return {};
+        }
+    };
+    const stored = read();
+    const save = () => {
+        writeFileSync(`${path}.tmp`, JSON.stringify(stored), { mode: 0o600, flush: true });
+        renameSync(`${path}.tmp`, path);
+    };
+    /** A service on this machine, by what it wrote; it needn't be running. */
+    const localService = () => {
+        const data = options.dataFolder ?? defaultDataFolder();
+        try {
+            const { url, pid } = JSON.parse(readFileSync(join(data, "server.json"), "utf8"));
+            // A service that crashed leaves this behind: nothing else on its port gets the token.
+            process.kill(pid, 0);
+            return { apiUrl: url, apiKey: readFileSync(join(data, "control-token"), "utf8").trim() };
+        }
+        catch {
+            return undefined;
+        }
+    };
+    /** The service on this machine, if it answers now. */
+    const findLocal = async () => {
+        const reached = localService();
+        if (!reached)
+            return undefined;
+        let timer;
+        try {
+            return await Promise.race([
+                Computer.serviceInfo(reached),
+                new Promise((resolve) => {
+                    timer = setTimeout(resolve, SERVICE_ANSWERS_MS, undefined);
+                }),
+            ]);
+        }
+        catch {
+            return undefined;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    };
+    const running = new Map();
+    /** Connect a link. A service on this machine may have moved to another port since. */
+    const open = async ({ url, actor, credential }, computer) => {
+        const moved = computer && "local" in computer.service ? localService()?.apiUrl : undefined;
+        const token = computer?.token;
+        const server = new Connection({ kind: "url", url: moved ? at(moved, url) : url }, token ? { token } : {}, log, options.timing);
+        await server.join({ hubUrl, actorId: actor, credential });
+        return server;
+    };
+    const endAll = () => Promise.all([...running.values()].flat().map((server) => server.end()));
+    const held = (instance) => {
+        const found = stored[instance];
+        const servers = running.get(instance);
+        if (!found || !servers)
+            throw new Refused("unknown", `This provider holds nothing named ${instance}.`);
+        return { found, servers };
+    };
+    const reachOf = (service) => "local" in service ? localService() : service;
+    /**
+     * The computer goes. Only a service having trouble is worth another try: one that can't be
+     * reached, or no longer takes this token, mustn't keep the agent from going.
+     */
+    const killComputer = async ({ id, service }) => {
+        const reached = reachOf(service);
+        try {
+            if (!reached)
+                throw new Error("The service isn't there.");
+            await Computer.kill(id, reached);
+        }
+        catch (error) {
+            if (error instanceof ComputerError && error.code >= 500)
+                throw error;
+            if (!(error instanceof ComputerError && error.code === 404))
+                log.error(`A computer may be left on its service: ${messageOf(error)}`);
+        }
+    };
+    for (const [instance, entry] of Object.entries(stored)) {
+        const servers = [];
+        try {
+            for (const link of entry.links)
+                servers.push(await open(link, entry.computer));
+            running.set(instance, servers);
+            for (const server of servers)
+                server.run();
+        }
+        catch (error) {
+            log.error(`${instance} didn't rejoin the Hub: ${String(error)}`);
+            await Promise.all(servers.map((server) => server.end()));
+            // The Hub no longer knows it: its Actors were closed while the provider was away.
+            if (error instanceof Refused && error.code === "forbidden") {
+                if (entry.computer)
+                    await killComputer(entry.computer).catch(() => { });
+                delete stored[instance];
+                save();
+            }
+        }
+    }
+    /** The folder an agent with this name works in when none is named. It stays when the agent goes. */
+    const agentFolder = (agentName) => {
+        const safe = agentName
+            .trim()
+            .replace(/[/\\\p{Cc}]/gu, "-")
+            .replace(/^\.+/, "")
+            .trim() || "agent";
+        const folder = join(options.agentsFolder ?? join(homedir(), "Agents"), safe);
+        try {
+            mkdirSync(folder, { recursive: true });
+        }
+        catch {
+            throw new Refused("invalid", `The folder ${folder} can't be made.`);
+        }
+        return folder;
+    };
+    /** What of a computer can be opened live, as its service says; none if it can't say now. */
+    const asked = new Map();
+    /** One question at a time per computer, and its answer kept a little while. */
+    const surfacesOf = (computer) => {
+        const kept = asked.get(computer.id);
+        if (kept && Date.now() - kept.at < SURFACES_FRESH_MS)
+            return kept.answer;
+        const answer = askSurfaces(computer);
+        asked.set(computer.id, { at: Date.now(), answer });
+        return answer;
+    };
+    const askSurfaces = async (computer) => {
+        const reached = reachOf(computer.service);
+        if (!reached)
+            return undefined;
+        let timer;
+        try {
+            const info = await Promise.race([
+                Computer.getInfo(computer.id, reached),
+                new Promise((resolve) => {
+                    timer = setTimeout(resolve, SURFACES_MS, undefined);
+                }),
+            ]);
+            return info?.surfaces.map(({ surface, protocol, operate, unavailable }) => ({
+                surface,
+                protocol,
+                operate,
+                ...(unavailable ? { unavailable } : {}),
+            }));
+        }
+        catch {
+            return undefined;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    };
+    /** Make the computer, and say what each of its endpoints is. */
+    const makeComputer = async (values, secrets, name, agent, agentName) => {
+        const local = values.service === LOCAL;
+        const reached = local
+            ? localService()
+            : { apiUrl: String(values.address).replace(/\/$/, ""), apiKey: secrets.token };
+        if (!reached)
+            throw new Refused("invalid", INSTALL_STEPS);
+        const { isolation } = await Computer.serviceInfo(reached);
+        const access = values.access;
+        const workspace = (local
+            ? (fromHome(values.workspace) ?? (agentName ? agentFolder(agentName) : undefined))
+            : values.path);
+        const computer = await Computer.create({
+            ...reached,
+            access,
+            browser: values.browser === true,
+            name,
+            metadata: { agent },
+            ...(workspace ? { workspace } : {}),
+        });
+        // The folder, so the person can find it: the service says where one it made is.
+        const folder = workspace ??
+            (await computer.getInfo().then((info) => info.workspace, () => null));
+        const where = local ? "this machine" : new URL(reached.apiUrl).host;
+        const on = isolation === "container" ? `${where}, in a container` : `${where}, no isolation`;
+        const servers = [];
+        if (access !== "none")
+            servers.push({
+                slot: COMPUTER,
+                url: at(reached.apiUrl, computer.getMcpUrl("computer")),
+                target: `${on}: ${SAYS[access]}${folder ? ` in ${folder}` : ""}`,
+            });
+        if (values.browser === true)
+            servers.push({
+                slot: BROWSER_SLOT,
+                url: at(reached.apiUrl, computer.getMcpUrl("browser")),
+                target: `A browser, ${on}`,
+            });
+        const held = {
+            id: computer.computerID,
+            token: computer.getMcpToken(),
+            service: local ? { local: true } : reached,
+        };
+        return { servers, computer: held };
+    };
+    let closing = false;
+    const provider = await connect({
+        hubUrl,
+        actorId: options.actorId,
+        credential: options.credential,
+        slots: { actors: hubActors },
+        exports: { provider: unitProvider },
+        log,
+        start(ctx) {
+            const known = (unit) => {
+                if (unit !== COMPUTER && unit !== WEB)
+                    throw new Refused("unknown", `This provider has no unit ${unit}.`);
+            };
+            ctx.exports.provider.implement({
+                units: async () => ({ units: [computerUnit(await findLocal()), WEB_UNIT] }),
+                async skill({ unit, name, path: file }) {
+                    if (!SKILLS[unit]?.includes(name) || file !== "SKILL.md")
+                        throw new Refused("unknown", `${unit} has no file ${file} of a skill ${name}.`);
+                    return { text: await readFile(join(SKILLS_DIR, name, file), "utf8") };
+                },
+                async check({ unit, values, secrets }) {
+                    known(unit);
+                    return { problems: problems(unit, values, await findLocal(), secrets) };
+                },
+                async apply({ unit, values, secrets, name, agent, agentName }) {
+                    known(unit);
+                    const wrong = problems(unit, values, await findLocal(), Object.keys(secrets));
+                    if (wrong.length > 0)
+                        throw new Refused("invalid", wrong.map((problem) => problem.message).join(" "));
+                    const instance = `${unit}_${randomBytes(9).toString("hex")}`;
+                    const web = { url: options.webUrl ?? EXA_URL };
+                    const { servers, computer } = unit === WEB
+                        ? {
+                            servers: [{ slot: WEB, url: web.url, target: new URL(web.url).host }],
+                            computer: undefined,
+                        }
+                        : await makeComputer(values, secrets, name, agent, agentName);
+                    const entry = { agent, links: [], ...(computer ? { computer } : {}) };
+                    const made = [];
+                    const connections = [];
+                    try {
+                        for (const { slot, url, target } of servers) {
+                            // A name of its own for each, as a computer can be two Actors.
+                            const { actorId, credential } = await ctx.slots.actors.call.create({
+                                name: servers.length > 1 ? `${name} (${slot})`.slice(0, 128) : name,
+                            });
+                            const link = { slot, actor: actorId, credential: credential, url };
+                            entry.links.push(link);
+                            made.push(await open(link, computer));
+                            connections.push({ slot, connection: actorId, target });
+                        }
+                        if (closing)
+                            throw new Refused("unavailable", "This provider is stopping.");
+                        running.set(instance, made);
+                        stored[instance] = entry;
+                        save();
+                        for (const server of made)
+                            server.run();
+                    }
+                    catch (error) {
+                        running.delete(instance);
+                        delete stored[instance];
+                        await Promise.all(made.map((server) => server.end()));
+                        for (const { actor } of entry.links)
+                            await ctx.slots.actors.call.close({ actorId: actor }).catch(() => { });
+                        if (computer)
+                            await killComputer(computer).catch((failed) => log.warn(`A computer may be left on its service: ${String(failed)}`));
+                        throw error;
+                    }
+                    return { instance, connections, results: [] };
+                },
+                status: async ({ instance }) => {
+                    const { found, servers } = held(instance);
+                    const each = servers.map((server, i) => ({
+                        connection: found.links[i].actor,
+                        ...server.status(),
+                    }));
+                    const down = each.find((one) => one.state === "down");
+                    const waiting = each.some((one) => one.state === "connecting");
+                    const surfaces = found.computer ? await surfacesOf(found.computer) : undefined;
+                    return {
+                        state: down
+                            ? "down"
+                            : waiting
+                                ? "connecting"
+                                : "connected",
+                        ...(down?.detail ? { detail: down.detail } : {}),
+                        connections: each,
+                        ...(surfaces ? { surfaces } : {}),
+                    };
+                },
+                async live({ instance, surface, mode }) {
+                    const { found } = held(instance);
+                    const reached = found.computer && reachOf(found.computer.service);
+                    if (!found.computer || !reached)
+                        throw new Refused("unknown", "Nothing of this can be opened live.");
+                    try {
+                        const session = await Computer.createLiveSession(found.computer.id, { surface: surface, mode }, reached);
+                        return {
+                            url: socketAt(reached.apiUrl, session.url),
+                            protocol: session.protocol,
+                            expiresAt: session.expiresAt,
+                        };
+                    }
+                    catch (error) {
+                        if (!(error instanceof ComputerError))
+                            throw error;
+                        throw new Refused(error.code === 404 || error.code === 400
+                            ? "unknown"
+                            : error.code === 409
+                                ? "state"
+                                : "failed", error.message);
+                    }
+                },
+                async remove({ instance }) {
+                    const { found, servers } = held(instance);
+                    // First: if the service refuses, the rest is still here to be tried again.
+                    if (found.computer)
+                        await killComputer(found.computer);
+                    for (const { actor } of found.links)
+                        await ctx.slots.actors.call.close({ actorId: actor });
+                    running.delete(instance);
+                    delete stored[instance];
+                    try {
+                        save();
+                    }
+                    finally {
+                        await Promise.all(servers.map((server) => server.end()));
+                    }
+                    return {};
+                },
+            });
+        },
+    }).catch(async (error) => {
+        await endAll();
+        throw error;
+    });
+    return {
+        async close() {
+            closing = true;
+            await endAll();
+            provider.close();
+        },
+    };
+}

package/dist/node_modules/@agentorg/computer-connector/dist/src/unit.d.ts

@@ -0,0 +1,19 @@
+import type { Unit } from "@agentorg/interfaces";
+import type { z } from "zod";
+export declare const COMPUTER = "computer";
+export declare const WEB = "web";
+export declare const BROWSER_SLOT = "browser";
+export type Access = "read" | "files" | "terminal";
+export declare const LOCAL = "local";
+export declare const ANOTHER = "another";
+/** What to do when there is no service here: the app never starts or ships one. */
+export declare const INSTALL_STEPS = "No AgentComputer is running on this machine. Install it with npm install -g @agentorg/computer, start it with agentcomputer serve, and try again.";
+/** How the service on this machine isolates its computers, if one is running. */
+export type Found = {
+    isolation: "none" | "container";
+} | undefined;
+/** The form as it stands now, with what was found on this machine. */
+export declare const computerUnit: (found: Found) => z.input<typeof Unit>;
+export declare const WEB_UNIT: z.input<typeof Unit>;
+/** The skills each unit can give, by name. */
+export declare const SKILLS: Record<string, string[]>;

package/dist/node_modules/@agentorg/computer-connector/dist/src/unit.js

@@ -0,0 +1,149 @@
+export const COMPUTER = "computer";
+export const WEB = "web";
+export const BROWSER_SLOT = "browser";
+const SKILL = "SKILL.md";
+const skill = (name) => ({ name, files: [SKILL] });
+const WITH_FILES = { slots: [{ name: COMPUTER }], skills: [skill("files"), skill("computer")] };
+export const LOCAL = "local";
+export const ANOTHER = "another";
+/** What to do when there is no service here: the app never starts or ships one. */
+export const INSTALL_STEPS = "No AgentComputer is running on this machine. Install it with npm install -g @agentorg/computer, start it with agentcomputer serve, and try again.";
+const localLine = (found) => !found
+    ? INSTALL_STEPS
+    : found.isolation === "container"
+        ? "On this machine, started by you. Each computer is a container of its own."
+        : "On this machine, started by you. No isolation: it acts as you, and with a terminal it reaches everything you can.";
+/** The form as it stands now, with what was found on this machine. */
+export const computerUnit = (found) => ({
+    id: COMPUTER,
+    title: "Computer",
+    description: "A place for the agent to work: a folder, how far it can act on it, and a browser.",
+    form: [
+        {
+            id: "service",
+            type: "choice",
+            value: "string",
+            title: "Service",
+            description: "Where its computer runs, and how that's kept apart from everything else.",
+            // Not required: with none found, `check` says what to do, which is more than "fill this in".
+            ...(found ? { default: LOCAL } : {}),
+            options: [
+                { value: LOCAL, title: "This machine", description: localLine(found) },
+                {
+                    value: ANOTHER,
+                    title: "Another address",
+                    description: "A service elsewhere. What a computer can reach depends on how it isolates.",
+                },
+            ],
+        },
+        {
+            id: "address",
+            type: "text",
+            value: "string",
+            title: "Address",
+            description: "The service's address, over https unless it's on this machine.",
+            required: true,
+            visible: { field: "service", in: [ANOTHER] },
+        },
+        {
+            id: "token",
+            type: "secret",
+            value: "secret",
+            title: "Token",
+            description: "The service's control token. It's asked each time and never saved in a template.",
+            required: true,
+            visible: { field: "service", in: [ANOTHER] },
+        },
+        {
+            id: "access",
+            authority: "setting",
+            type: "choice",
+            value: "string",
+            title: "What it can do",
+            required: true,
+            options: [
+                { value: "none", title: "Nothing", description: "It has no files and can't run anything." },
+                {
+                    value: "read",
+                    title: "Read files",
+                    description: "It can read files in its working directory, but can't change them or run anything.",
+                    adds: WITH_FILES,
+                },
+                {
+                    value: "files",
+                    title: "Read and change files",
+                    description: "It can read and change files in its working directory, but can't run anything.",
+                    adds: WITH_FILES,
+                },
+                {
+                    value: "terminal",
+                    title: "Files and terminal",
+                    description: "It can run any command, so it can reach every file and program you can.",
+                    adds: {
+                        slots: [{ name: COMPUTER }],
+                        skills: [skill("terminal"), skill("files"), skill("computer")],
+                    },
+                },
+            ],
+        },
+        {
+            id: "browser",
+            authority: "setting",
+            type: "toggle",
+            value: "boolean",
+            title: "Browser",
+            description: "It can open web pages and act on them, in a browser of its own.",
+            default: false,
+            adds: { slots: [{ name: BROWSER_SLOT }], skills: [skill("browser")] },
+        },
+        {
+            id: "workspace",
+            type: "directory",
+            value: "string",
+            title: "Working directory",
+            description: "The folder it works in. Left empty, it's a folder with the agent's name in ~/Agents, made if it's missing. Its file tools stay inside it by a check, not a sandbox. Removing the agent leaves it.",
+            placeholder: "~/Agents/{name}",
+            visible: { field: "service", in: [LOCAL] },
+        },
+        {
+            id: "path",
+            type: "text",
+            value: "string",
+            title: "Working directory",
+            description: "A path on the service's machine. Removing the agent leaves it.",
+            visible: { field: "service", in: [ANOTHER] },
+        },
+    ],
+    needs: [],
+    gives: { slots: [], skills: [], results: [] },
+});
+export const WEB_UNIT = {
+    id: WEB,
+    title: "Web search",
+    description: "Search the web and read pages.",
+    form: [
+        {
+            id: "service",
+            authority: "setting",
+            type: "choice",
+            value: "string",
+            title: "Service",
+            required: true,
+            default: "exa",
+            options: [
+                {
+                    value: "exa",
+                    title: "Exa",
+                    description: "It searches and reads pages through Exa, which sees what it looks for.",
+                },
+            ],
+        },
+    ],
+    needs: [],
+    gives: { slots: [{ name: WEB }], skills: [skill("web-research")], results: [] },
+};
+/** The skills each unit can give, by name. */
+export const SKILLS = {
+    [COMPUTER]: ["terminal", "files", "computer", "browser"],
+    [WEB]: ["web-research"],
+};

package/dist/node_modules/@agentorg/computer-connector/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@agentorg/computer-connector",
+  "version": "0.0.0",
+  "private": true,
+  "description": "The computer unit: a terminal and files for an agent, on a machine the person chooses",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "default": "./dist/src/index.js"
+    }
+  },
+  "files": [
+    "dist/src",
+    "skills"
+  ],
+  "scripts": {
+    "build": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && tsc -p tsconfig.json",
+    "test": "node --test \"dist/test/**/*.test.js\""
+  },
+  "dependencies": {
+    "@agentorg/computer": "0.0.10",
+    "@agentorg/interfaces": "0.0.0",
+    "@agentorg/mcp": "0.0.0",
+    "@agentorg/sdk": "0.0.0",
+    "zod": "^4.6.7"
+  },
+  "devDependencies": {
+    "@agentorg/hub": "0.0.0",
+    "@modelcontextprotocol/server": "2.4.0"
+  }
+}