@atomicmail/agent-skill 0.1.0 → 0.2.0

package/esm/lib/src/agent-session.js

@@ -0,0 +1,206 @@
+// Stateful PoW + capability JWT + optional cached JMAP session (accountId).
+import { tryReadCredentials, tryReadJwtFile, unlinkCredentialArtifacts, writeCredentials, writeJwtFile, } from "./agent-credentials-store.js";
+import { CAPABILITY_SAFETY_MARGIN_MS, decodeJwtPayload, isJwtExpired, SESSION_SAFETY_MARGIN_MS, } from "./agent-jwt.js";
+import { extractPrimaryMailAccountId, fetchJmapWellKnown, } from "./agent-jmap.js";
+import { fetchCapability, performPoWAndSession } from "./agent-auth-http.js";
+function normalizeUsername(u) {
+    return u.trim().toLowerCase();
+}
+/** Local-part of an inbox email, or the whole string if no @. */
+export function inboxLocalPart(inboxId) {
+    const i = inboxId.indexOf("@");
+    return i === -1
+        ? normalizeUsername(inboxId)
+        : normalizeUsername(inboxId.slice(0, i));
+}
+export class AgentSession {
+    authUrl;
+    apiUrl;
+    scryptSalt;
+    apiKey;
+    inboxId;
+    credentialDir;
+    files;
+    sessionJWT;
+    capabilityJWT;
+    cachedMailAccountId;
+    constructor(cfg) {
+        this.authUrl = cfg.authUrl.replace(/\/+$/, "");
+        this.apiUrl = cfg.apiUrl.replace(/\/+$/, "");
+        this.scryptSalt = cfg.scryptSalt;
+        this.apiKey = cfg.apiKey;
+        this.inboxId = cfg.inboxId;
+        this.credentialDir = cfg.credentialDir;
+        this.files = cfg.files;
+    }
+    static async create(cfg) {
+        const session = new AgentSession(cfg);
+        await session.loadFromDisk();
+        return session;
+    }
+    get hasApiKey() {
+        return this.apiKey !== undefined && this.apiKey.length > 0;
+    }
+    get currentInboxId() {
+        return this.inboxId;
+    }
+    async loadFromDisk() {
+        this.sessionJWT = await tryReadJwtFile(this.files.sessionFile);
+        this.capabilityJWT = await tryReadJwtFile(this.files.capabilityFile);
+        const disk = await tryReadCredentials(this.files.credentialsFile);
+        if (disk) {
+            this.apiKey = this.apiKey ?? disk.apiKey;
+            this.inboxId = this.inboxId ?? disk.inboxId;
+        }
+    }
+    /**
+     * Primary JMAP mail accountId from GET /.well-known/jmap (cached).
+     */
+    async getPrimaryMailAccountId() {
+        if (this.cachedMailAccountId)
+            return this.cachedMailAccountId;
+        const cap = await this.getCapabilityToken();
+        const session = await fetchJmapWellKnown(this.apiUrl, cap);
+        const id = extractPrimaryMailAccountId(session);
+        this.cachedMailAccountId = id;
+        return id;
+    }
+    invalidateJmapSessionCache() {
+        this.cachedMailAccountId = undefined;
+    }
+    /**
+     * Register or return existing inbox when username matches (idempotent).
+     * Different username replaces on-disk credentials and creates a new inbox.
+     */
+    async register(username) {
+        const want = normalizeUsername(username);
+        if (this.hasApiKey && !this.inboxId) {
+            throw new Error("Cannot register: an API key is configured but inboxId is unknown. " +
+                "Fix credentials.json or unset ATOMIC_MAIL_API_KEY before registering.");
+        }
+        if (this.hasApiKey && this.inboxId) {
+            const have = inboxLocalPart(this.inboxId);
+            if (have === want) {
+                const accountId = await this.getPrimaryMailAccountId();
+                return {
+                    inbox: this.inboxId,
+                    accountId,
+                    idempotent: true,
+                };
+            }
+            await unlinkCredentialArtifacts(this.files);
+            this.apiKey = undefined;
+            this.inboxId = undefined;
+            this.sessionJWT = undefined;
+            this.capabilityJWT = undefined;
+            this.cachedMailAccountId = undefined;
+        }
+        const result = await performPoWAndSession({
+            authUrl: this.authUrl,
+            scryptSalt: this.scryptSalt,
+            username,
+        });
+        if (!result.apiKey) {
+            throw new Error("Signup did not return an apiKey — this indicates a server bug.");
+        }
+        this.apiKey = result.apiKey;
+        this.sessionJWT = result.sessionJWT;
+        await writeJwtFile(this.files.sessionFile, this.sessionJWT);
+        const capability = await fetchCapability(this.authUrl, this.sessionJWT);
+        this.capabilityJWT = capability;
+        await writeJwtFile(this.files.capabilityFile, capability);
+        const claims = decodeJwtPayload(capability);
+        if (typeof claims.inboxId !== "string" || claims.inboxId.length === 0) {
+            throw new Error("Capability JWT missing inboxId claim after signup.");
+        }
+        this.inboxId = claims.inboxId;
+        this.cachedMailAccountId = undefined;
+        const creds = {
+            apiKey: this.apiKey,
+            inboxId: this.inboxId,
+            authUrl: this.authUrl,
+            apiUrl: this.apiUrl,
+            scryptSalt: this.scryptSalt,
+        };
+        await writeCredentials(this.files.credentialsFile, creds);
+        const accountId = await this.getPrimaryMailAccountId();
+        return {
+            inbox: this.inboxId,
+            accountId,
+            apiKey: this.apiKey,
+        };
+    }
+    async getCapabilityToken() {
+        if (this.capabilityJWT &&
+            !isJwtExpired(this.capabilityJWT, CAPABILITY_SAFETY_MARGIN_MS)) {
+            return this.capabilityJWT;
+        }
+        await this.ensureSession();
+        if (!this.sessionJWT) {
+            throw new Error("Internal: ensureSession() left sessionJWT unset.");
+        }
+        const cap = await fetchCapability(this.authUrl, this.sessionJWT);
+        this.capabilityJWT = cap;
+        await writeJwtFile(this.files.capabilityFile, cap);
+        try {
+            const claims = decodeJwtPayload(cap);
+            if (typeof claims.inboxId === "string" && claims.inboxId.length > 0) {
+                this.inboxId = claims.inboxId;
+            }
+        }
+        catch {
+            // non-fatal
+        }
+        return cap;
+    }
+    async ensureSession() {
+        if (this.sessionJWT &&
+            !isJwtExpired(this.sessionJWT, SESSION_SAFETY_MARGIN_MS)) {
+            return;
+        }
+        if (!this.apiKey) {
+            throw new Error("No API key configured and no valid session on disk. Run register " +
+                "first, set ATOMIC_MAIL_API_KEY, or place credentials.json in the " +
+                "credential directory.");
+        }
+        const result = await performPoWAndSession({
+            authUrl: this.authUrl,
+            scryptSalt: this.scryptSalt,
+            apiKey: this.apiKey,
+        });
+        this.sessionJWT = result.sessionJWT;
+        this.capabilityJWT = undefined;
+        this.cachedMailAccountId = undefined;
+        await writeJwtFile(this.files.sessionFile, this.sessionJWT);
+    }
+    destroy() {
+        // reserved
+    }
+}
+/** PoW login with an existing API key; writes credentials + JWT files. */
+export async function persistLoginWithApiKey(input) {
+    const authUrl = input.authUrl.replace(/\/+$/, "");
+    const apiUrl = input.apiUrl.replace(/\/+$/, "");
+    const session = await performPoWAndSession({
+        authUrl,
+        scryptSalt: input.scryptSalt,
+        apiKey: input.apiKey,
+        onPowProgress: input.onPowProgress,
+    });
+    const capabilityJWT = await fetchCapability(authUrl, session.sessionJWT);
+    const claims = decodeJwtPayload(capabilityJWT);
+    const inboxId = claims.inboxId;
+    if (typeof inboxId !== "string" || inboxId.length === 0) {
+        throw new Error("Capability JWT did not contain an inboxId claim.");
+    }
+    await writeCredentials(input.files.credentialsFile, {
+        apiKey: input.apiKey,
+        inboxId,
+        authUrl,
+        apiUrl,
+        scryptSalt: input.scryptSalt,
+    });
+    await writeJwtFile(input.files.sessionFile, session.sessionJWT);
+    await writeJwtFile(input.files.capabilityFile, capabilityJWT);
+    return { inboxId };
+}

package/esm/lib/src/agent-vars.d.ts

@@ -0,0 +1,23 @@
+/** Matches `$FOO_BAR`; excludes JMAP keywords like `$draft` (lowercase). */
+export declare const VAR_PATTERN: RegExp;
+/** Names substituted from JMAP session / credentials when not overridden in `vars`. */
+export declare const SESSION_VAR_NAMES: Set<string>;
+export interface SubstituteVarsInput {
+    raw: string;
+    /** Caller-supplied values; keys are names without `$` (e.g. `TO`, `SUBJECT`). */
+    vars?: Record<string, string>;
+    /** Invoked only when the name appears in `raw`, is absent from `vars`, and a resolver exists. */
+    autoResolvers?: Record<string, () => Promise<string> | string>;
+}
+export interface SubstituteVarsResult {
+    text: string;
+}
+/** Unique variable names in order of first occurrence (without leading `$`). */
+export declare function findVarReferences(raw: string): string[];
+/**
+ * Replaces every `$VAR_NAME` in `raw` with the corresponding string.
+ * Single pass — values are not scanned for further `$` tokens.
+ * Throws if any referenced variable has no value (after vars + autoResolvers).
+ */
+export declare function substituteVars(input: SubstituteVarsInput): Promise<SubstituteVarsResult>;
+//# sourceMappingURL=agent-vars.d.ts.map

package/esm/lib/src/agent-vars.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-vars.d.ts","sourceRoot":"","sources":["../../../src/lib/src/agent-vars.ts"],"names":[],"mappings":"AAEA,4EAA4E;AAC5E,eAAO,MAAM,WAAW,QAAyB,CAAC;AAMlD,uFAAuF;AACvF,eAAO,MAAM,iBAAiB,aAA2C,CAAC;AAE1E,MAAM,WAAW,mBAAmB;IAClC,GAAG,EAAE,MAAM,CAAC;IACZ,iFAAiF;IACjF,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,iGAAiG;IACjG,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC;CAChE;AAED,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAC;CACd;AAED,gFAAgF;AAChF,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAWvD;AAeD;;;;GAIG;AACH,wBAAsB,cAAc,CAClC,KAAK,EAAE,mBAAmB,GACzB,OAAO,CAAC,oBAAoB,CAAC,CA+B/B"}

package/esm/lib/src/agent-vars.js

@@ -0,0 +1,65 @@
+// Variable substitution for JMAP presets / inline ops ($VAR_NAME tokens).
+/** Matches `$FOO_BAR`; excludes JMAP keywords like `$draft` (lowercase). */
+export const VAR_PATTERN = /\$([A-Z][A-Z0-9_]*)/g;
+function varPattern() {
+    return new RegExp(VAR_PATTERN.source, VAR_PATTERN.flags);
+}
+/** Names substituted from JMAP session / credentials when not overridden in `vars`. */
+export const SESSION_VAR_NAMES = new Set(["ACCOUNT_ID", "INBOX"]);
+/** Unique variable names in order of first occurrence (without leading `$`). */
+export function findVarReferences(raw) {
+    const seen = new Set();
+    const order = [];
+    for (const m of raw.matchAll(varPattern())) {
+        const name = m[1];
+        if (!seen.has(name)) {
+            seen.add(name);
+            order.push(name);
+        }
+    }
+    return order;
+}
+function formatMissingError(missing) {
+    const tokens = missing.map((n) => `$${n}`);
+    const hasSession = missing.some((n) => SESSION_VAR_NAMES.has(n));
+    let msg = `Missing values for variables: ${tokens.join(", ")}. ` +
+        "Pass custom placeholders in vars (MCP) or --vars (skill).";
+    if (hasSession) {
+        msg +=
+            " For $ACCOUNT_ID and $INBOX, ensure register completed and credentials are valid, " +
+                "or pass overrides in vars.";
+    }
+    return new Error(msg);
+}
+/**
+ * Replaces every `$VAR_NAME` in `raw` with the corresponding string.
+ * Single pass — values are not scanned for further `$` tokens.
+ * Throws if any referenced variable has no value (after vars + autoResolvers).
+ */
+export async function substituteVars(input) {
+    const names = findVarReferences(input.raw);
+    if (names.length === 0) {
+        return { text: input.raw };
+    }
+    const userVars = input.vars ?? {};
+    const resolved = new Map();
+    for (const name of names) {
+        if (Object.prototype.hasOwnProperty.call(userVars, name)) {
+            resolved.set(name, userVars[name]);
+            continue;
+        }
+        const resolver = input.autoResolvers?.[name];
+        if (resolver) {
+            resolved.set(name, await resolver());
+            continue;
+        }
+    }
+    const missing = names.filter((n) => !resolved.has(n));
+    if (missing.length > 0) {
+        throw formatMissingError(missing);
+    }
+    const text = input.raw.replace(varPattern(), (_full, name) => {
+        return resolved.get(name);
+    });
+    return { text };
+}

package/esm/skill/scripts/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/esm/skill/scripts/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../../src/skill/scripts/cli.ts"],"names":[],"mappings":""}

package/esm/skill/scripts/cli.js

@@ -0,0 +1,309 @@
+#!/usr/bin/env node
+// Atomic Mail AgentSkill — register | jmap_request | help
+import process from "node:process";
+import { parseArgs } from "node:util";
+import { resolve } from "node:path";
+import { homedir } from "node:os";
+import { DEFAULT_POW_SCRYPT_SALT_HEX } from "../../lib/src/consts.js";
+import { getHelp } from "../../lib/src/agent-help-content.js";
+import { DEFAULT_JMAP_USING, readOpsFile, runJmapRequest, } from "../../lib/src/agent-jmap.js";
+import { AgentSession, persistLoginWithApiKey, } from "../../lib/src/agent-session.js";
+import { defaultFilesFromOutDir, readCredentials, } from "../../lib/src/agent-credentials-store.js";
+const USAGE = `Atomic Mail — AgentSkill
+
+Usage:
+  atomicmail <command> [options]
+
+Commands:
+  register       PoW signup or login with API key (writes credentials)
+  jmap_request   Send a JMAP batch (inline --ops or --ops-file preset)
+  help           Full documentation [--topic TOPIC]
+
+Examples:
+  atomicmail register --username alice
+  atomicmail register --api-key UUID
+  atomicmail jmap_request --credentials-dir ./.atomic-mail --ops-file fetch.json
+  atomicmail jmap_request --credentials-dir ./.atomic-mail --ops-file send.json --vars '{"TO":"a@b.com","SUBJECT":"Hi"}'
+  atomicmail help --topic presets
+
+Run  atomicmail <command> --help  for command-specific flags.
+`;
+function exitUsage(code = 0) {
+    process.stdout.write(USAGE);
+    process.exit(code);
+}
+function fail(message, code = 1) {
+    process.stderr.write(`Error: ${message}\n`);
+    process.exit(code);
+}
+function resolveCredentialDir(dir) {
+    const raw = dir ?? process.env.ATOMIC_MAIL_CREDENTIALS_DIR ?? "~/.atomicmail";
+    if (raw === "~")
+        return homedir();
+    return resolve(raw.replace(/^~\//, `${homedir()}/`));
+}
+async function cmdRegister(argv) {
+    let parsed;
+    try {
+        parsed = parseArgs({
+            args: argv,
+            options: {
+                "auth-url": { type: "string" },
+                "api-url": { type: "string" },
+                "scrypt-salt": { type: "string" },
+                username: { type: "string" },
+                "api-key": { type: "string" },
+                "credentials-dir": { type: "string" },
+                quiet: { type: "boolean" },
+                help: { type: "boolean", short: "h" },
+            },
+            strict: true,
+            allowPositionals: false,
+        });
+    }
+    catch (err) {
+        fail(err.message, 2);
+    }
+    if (parsed.values.help) {
+        process.stdout.write(`Usage: atomicmail register [OPTIONS]
+
+Register a new inbox (--username) or log in with an existing API key (--api-key).
+
+Options:
+  --auth-url URL       Auth-service base URL [env: ATOMIC_MAIL_AUTH_URL, default: https://auth.atomicmail.ai]
+  --api-url URL        API / JMAP base URL [env: ATOMIC_MAIL_API_URL, default: https://api.atomicmail.ai]
+  --scrypt-salt SALT   PoW salt override [env: ATOMIC_MAIL_SCRYPT_SALT]
+  --username NAME      New account (mutually exclusive with --api-key)
+  --api-key KEY        Existing API key (mutually exclusive with --username)
+  --credentials-dir DIR  Credential directory (default: ~/.atomicmail)
+  --quiet              Less stderr output
+  --help, -h           This message
+`);
+        process.exit(0);
+    }
+    const env = process.env;
+    const authUrl = parsed.values["auth-url"] ??
+        env.ATOMIC_MAIL_AUTH_URL ?? "https://auth.atomicmail.ai";
+    const apiUrl = parsed.values["api-url"] ??
+        env.ATOMIC_MAIL_API_URL ?? "https://api.atomicmail.ai";
+    const scryptSalt = parsed.values["scrypt-salt"] ??
+        env.ATOMIC_MAIL_SCRYPT_SALT ?? DEFAULT_POW_SCRYPT_SALT_HEX;
+    const dir = parsed.values["credentials-dir"];
+    const credentialDir = resolveCredentialDir(dir);
+    const username = parsed.values.username;
+    const apiKey = parsed.values["api-key"];
+    if (!!username === !!apiKey) {
+        fail("Provide exactly one of --username (new account) or --api-key (login).", 2);
+    }
+    const files = defaultFilesFromOutDir(credentialDir);
+    const log = (msg) => {
+        if (!parsed.values.quiet)
+            process.stderr.write(msg + "\n");
+    };
+    if (username) {
+        log(`Registering "${username}"...`);
+        const session = await AgentSession.create({
+            authUrl,
+            apiUrl,
+            scryptSalt,
+            credentialDir,
+            files,
+        });
+        const result = await session.register(username);
+        log(`Wrote credentials under ${credentialDir}`);
+        process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+        return;
+    }
+    log("Logging in with API key...");
+    const { inboxId } = await persistLoginWithApiKey({
+        authUrl,
+        apiUrl,
+        scryptSalt,
+        apiKey: apiKey,
+        files,
+    });
+    log(`Wrote ${files.credentialsFile}`);
+    process.stdout.write(JSON.stringify({ inboxId }, null, 2) + "\n");
+}
+async function cmdJmapRequest(argv) {
+    let parsed;
+    try {
+        parsed = parseArgs({
+            args: argv,
+            options: {
+                "credentials-dir": { type: "string" },
+                "credentials-file": { type: "string" },
+                "session-file": { type: "string" },
+                "capability-file": { type: "string" },
+                ops: { type: "string" },
+                "ops-file": { type: "string" },
+                using: { type: "string" },
+                "dry-run": { type: "boolean" },
+                vars: { type: "string" },
+                help: { type: "boolean", short: "h" },
+            },
+            strict: true,
+            allowPositionals: false,
+        });
+    }
+    catch (err) {
+        fail(err.message, 2);
+    }
+    if (parsed.values.help) {
+        process.stdout.write(`Usage: atomicmail jmap_request [OPTIONS]
+
+Send a JMAP request using saved credentials.
+
+Options:
+  --credentials-dir DIR      Directory with credentials.json + JWTs (default: ~/.atomicmail)
+  --credentials-file PATH    Override credentials.json path
+  --session-file PATH        Override session.jwt path
+  --capability-file PATH     Override capability.jwt path
+  --ops JSON                 Inline JMAP JSON (methodCalls or envelope)
+  --ops-file PATH            Preset file ($VAR_NAME placeholders supported)
+  --vars JSON                JSON object { VAR_NAME: string } for $VAR_NAME in ops / ops-file
+  --using LIST               Comma-separated capability URNs (optional)
+  --dry-run                  Print resolved request only
+  --help, -h                 This message
+`);
+        process.exit(0);
+    }
+    const dir = parsed.values["credentials-dir"];
+    const credentialDir = resolveCredentialDir(dir);
+    const defaults = defaultFilesFromOutDir(credentialDir);
+    const credentialsFile = parsed.values["credentials-file"] ??
+        defaults.credentialsFile;
+    const sessionFile = parsed.values["session-file"] ??
+        defaults.sessionFile;
+    const capabilityFile = parsed.values["capability-file"] ??
+        defaults.capabilityFile;
+    const ops = parsed.values.ops;
+    const opsFile = parsed.values["ops-file"];
+    if (ops && opsFile) {
+        fail("--ops and --ops-file are mutually exclusive.", 2);
+    }
+    if (!ops && !opsFile) {
+        fail("Provide --ops or --ops-file.", 2);
+    }
+    const usingFlag = parsed.values.using;
+    const defaultUsing = usingFlag
+        ? usingFlag.split(",").map((s) => s.trim()).filter((s) => s.length > 0)
+        : [...DEFAULT_JMAP_USING];
+    let userVars;
+    const varsFlag = parsed.values.vars;
+    if (varsFlag !== undefined) {
+        let obj;
+        try {
+            obj = JSON.parse(varsFlag);
+        }
+        catch (err) {
+            fail(`--vars is not valid JSON: ${err.message}`, 2);
+        }
+        if (!obj || typeof obj !== "object" || Array.isArray(obj)) {
+            fail("--vars must be a JSON object of { VAR_NAME: string }.", 2);
+        }
+        for (const [k, v] of Object.entries(obj)) {
+            if (!/^[A-Z][A-Z0-9_]*$/.test(k)) {
+                fail(`--vars key '${k}' must match /^[A-Z][A-Z0-9_]*$/.`, 2);
+            }
+            if (typeof v !== "string") {
+                fail(`--vars value for '${k}' must be a string.`, 2);
+            }
+        }
+        userVars = obj;
+    }
+    const creds = await readCredentials(credentialsFile);
+    const files = {
+        credentialsFile,
+        sessionFile,
+        capabilityFile,
+    };
+    const session = await AgentSession.create({
+        authUrl: creds.authUrl,
+        apiUrl: creds.apiUrl,
+        scryptSalt: creds.scryptSalt,
+        apiKey: creds.apiKey,
+        inboxId: creds.inboxId,
+        credentialDir,
+        files,
+    });
+    let raw;
+    let sourceLabel;
+    if (opsFile) {
+        try {
+            raw = await readOpsFile(credentialDir, opsFile);
+        }
+        catch (err) {
+            fail(`Could not read --ops-file: ${err.message}`, 2);
+        }
+        sourceLabel = opsFile;
+    }
+    else {
+        raw = ops;
+        sourceLabel = "ops";
+    }
+    const { ok, status, bodyText } = await runJmapRequest({
+        session,
+        opsJson: raw,
+        defaultUsing,
+        sourceLabel,
+        dryRun: parsed.values["dry-run"] === true,
+        vars: userVars,
+    });
+    if (!ok) {
+        fail(`JMAP request failed (HTTP ${status}): ${bodyText}`, 1);
+    }
+    process.stdout.write(bodyText.endsWith("\n") ? bodyText : bodyText + "\n");
+}
+function cmdHelp(argv) {
+    let parsed;
+    try {
+        parsed = parseArgs({
+            args: argv,
+            options: {
+                topic: { type: "string" },
+                help: { type: "boolean", short: "h" },
+            },
+            strict: true,
+            allowPositionals: false,
+        });
+    }
+    catch (err) {
+        fail(err.message, 2);
+    }
+    if (parsed.values.help) {
+        process.stdout.write(`Usage: atomicmail help [--topic TOPIC]
+
+Topics include: overview, installation, auth, jmap_cheatsheet, tools, presets, troubleshooting.
+`);
+        process.exit(0);
+    }
+    const topic = parsed.values.topic;
+    process.stdout.write(getHelp(topic) + "\n");
+}
+async function main() {
+    const argv = process.argv.slice(2);
+    if (argv.length === 0 || argv[0] === "-h" || argv[0] === "--help") {
+        exitUsage(0);
+    }
+    const cmd = argv[0];
+    const rest = argv.slice(1);
+    switch (cmd) {
+        case "register":
+            await cmdRegister(rest);
+            break;
+        case "jmap_request":
+            await cmdJmapRequest(rest);
+            break;
+        case "help":
+            cmdHelp(rest);
+            break;
+        default:
+            process.stderr.write(`Unknown command: ${cmd}\n\n`);
+            process.stdout.write(USAGE);
+            process.exit(2);
+    }
+}
+main().catch((err) => {
+    fail(err instanceof Error ? err.message : String(err));
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@atomicmail/agent-skill",
-  "version": "0.1.0",
-  "description": "Atomic Mail agent skill — PoW signup + JMAP request CLIs for AI agents.",
+  "version": "0.2.0",
+  "description": "Atomic Mail AgentSkill — register, jmap_request, and help CLI for AI agents.",
   "keywords": [
     "atomic-mail",
     "atomicmail",
@@ -24,8 +24,7 @@
   },
   "scripts": {},
   "bin": {
-    "atomic-mail-signup": "./esm/skill/scripts/signup.js",
-    "atomic-mail-jmap": "./esm/skill/scripts/jmap_request.js"
+    "atomicmail": "./esm/skill/scripts/cli.js"
   },
   "engines": {
     "node": ">=20"

package/esm/skill/scripts/jmap_request.d.ts

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-export {};
-//# sourceMappingURL=jmap_request.d.ts.map

package/esm/skill/scripts/jmap_request.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"jmap_request.d.ts","sourceRoot":"","sources":["../../../src/skill/scripts/jmap_request.ts"],"names":[],"mappings":""}