@axisagent/cli 0.1.0

package/dist/relayClient.js

@@ -0,0 +1,109 @@
+import { access, readdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { getRegistryStats } from "./skillRegistry.js";
+async function pathExists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function countSkillDirs(path) {
+    try {
+        const entries = await readdir(path, { withFileTypes: true });
+        return entries.filter((entry) => entry.isDirectory()).length;
+    }
+    catch {
+        return 0;
+    }
+}
+async function detectAgents(baseDir) {
+    const home = homedir();
+    const codexSkills = join(home, ".codex", "skills");
+    const claudeSkills = join(home, "Library", "Application Support", "Claude", "skills");
+    const openClawWorkspaceSkills = join(baseDir, ".openclaw", "skills");
+    const openClawHomeSkills = join(home, ".openclaw", "skills");
+    const openClawSkills = (await pathExists(openClawWorkspaceSkills)) ? openClawWorkspaceSkills : openClawHomeSkills;
+    return [
+        {
+            id: "codex-local",
+            name: "Codex Local",
+            status: (await pathExists(codexSkills)) ? "ready" : "not-detected",
+            skillsPath: codexSkills,
+            installedSkills: await countSkillDirs(codexSkills)
+        },
+        {
+            id: "claude-desktop",
+            name: "Claude Desktop",
+            status: (await pathExists(claudeSkills)) ? "ready" : "not-detected",
+            skillsPath: claudeSkills,
+            installedSkills: await countSkillDirs(claudeSkills)
+        },
+        {
+            id: "openclaw",
+            name: "OpenClaw",
+            status: (await pathExists(openClawSkills)) ? "ready" : "not-detected",
+            skillsPath: openClawSkills,
+            installedSkills: await countSkillDirs(openClawSkills)
+        }
+    ];
+}
+function normalizeApiUrl(apiUrl) {
+    return apiUrl.replace(/\/$/, "");
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function postJson(url, body, token) {
+    const response = await fetch(url, {
+        method: "POST",
+        headers: {
+            "content-type": "application/json",
+            ...(token ? { authorization: `Bearer ${token}` } : {})
+        },
+        body: JSON.stringify(body)
+    });
+    const payload = await response.json().catch(() => null);
+    if (!response.ok) {
+        const message = payload && typeof payload === "object" && "error" in payload ? payload.error : `Axis API returned ${response.status}`;
+        throw new Error(message);
+    }
+    return payload;
+}
+async function createRelayPayload(baseDir, pairingCode) {
+    return {
+        pairingCode,
+        connector: {
+            name: "Axis Local Connector",
+            version: "0.1.0",
+            baseDir,
+            runtime: `node ${process.version}`,
+            capabilities: ["heartbeat", "skill-install", "skill-scan", "axis-check", "approval-ticket"]
+        },
+        agents: await detectAgents(baseDir),
+        registry: getRegistryStats()
+    };
+}
+export async function connectRelay(options) {
+    const apiUrl = normalizeApiUrl(options.apiUrl);
+    const pairingCode = options.pairingCode.toUpperCase();
+    const payload = await createRelayPayload(options.baseDir, pairingCode);
+    const connected = await postJson(`${apiUrl}/v1/relay/connect`, payload);
+    console.log(`Axis Relay connected: ${connected.session.pairingCode}`);
+    console.log(`Status: ${connected.session.status}`);
+    console.log(`API: ${apiUrl}`);
+    console.log(`Expires: ${connected.session.expiresAt}`);
+    if (options.once) {
+        return connected;
+    }
+    console.log("Keeping relay alive. Press Ctrl+C to stop.");
+    while (true) {
+        await delay(options.heartbeatIntervalMs);
+        const heartbeatPayload = await createRelayPayload(options.baseDir, pairingCode);
+        const heartbeat = await postJson(`${apiUrl}/v1/relay/${pairingCode}/heartbeat`, heartbeatPayload, connected.relayToken);
+        console.log(`[${heartbeat.session.lastSeenAt}] relay ${heartbeat.session.status}`);
+    }
+}

package/dist/schema.d.ts

@@ -0,0 +1,115 @@
+import { z } from "zod";
+export declare const riskSchema: z.ZodEnum<{
+    low: "low";
+    medium: "medium";
+    high: "high";
+    critical: "critical";
+}>;
+export declare const executionModeSchema: z.ZodEnum<{
+    "read-only": "read-only";
+    "approval-required": "approval-required";
+    "live-execution": "live-execution";
+}>;
+export declare const permissionSchema: z.ZodEnum<{
+    network: "network";
+    "market-data": "market-data";
+    "wallet-read": "wallet-read";
+    "wallet-signature": "wallet-signature";
+    "transaction-preview": "transaction-preview";
+    trading: "trading";
+    "api-key": "api-key";
+    notifications: "notifications";
+    "contract-call": "contract-call";
+    "filesystem-read": "filesystem-read";
+    "filesystem-write": "filesystem-write";
+    "secrets-read": "secrets-read";
+    "paid-api": "paid-api";
+    governance: "governance";
+    browser: "browser";
+}>;
+export declare const policySchema: z.ZodObject<{
+    defaultMode: z.ZodEnum<{
+        "read-only": "read-only";
+        "approval-required": "approval-required";
+        "live-execution": "live-execution";
+    }>;
+    requiresApproval: z.ZodBoolean;
+    networkAccess: z.ZodBoolean;
+    walletWrite: z.ZodBoolean;
+    secrets: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    allowedChains: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    maxSpendUsd: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    sessionLimitMinutes: z.ZodDefault<z.ZodNumber>;
+    humanReadableRule: z.ZodString;
+}, z.core.$strip>;
+export declare const skillDefinitionSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    category: z.ZodString;
+    summary: z.ZodString;
+    useWhen: z.ZodString;
+    chains: z.ZodArray<z.ZodString>;
+    protocols: z.ZodArray<z.ZodString>;
+    risk: z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        critical: "critical";
+    }>;
+    executionMode: z.ZodEnum<{
+        "read-only": "read-only";
+        "approval-required": "approval-required";
+        "live-execution": "live-execution";
+    }>;
+    permissions: z.ZodArray<z.ZodEnum<{
+        network: "network";
+        "market-data": "market-data";
+        "wallet-read": "wallet-read";
+        "wallet-signature": "wallet-signature";
+        "transaction-preview": "transaction-preview";
+        trading: "trading";
+        "api-key": "api-key";
+        notifications: "notifications";
+        "contract-call": "contract-call";
+        "filesystem-read": "filesystem-read";
+        "filesystem-write": "filesystem-write";
+        "secrets-read": "secrets-read";
+        "paid-api": "paid-api";
+        governance: "governance";
+        browser: "browser";
+    }>>;
+    installTargets: z.ZodArray<z.ZodEnum<{
+        codex: "codex";
+        claude: "claude";
+        openclaw: "openclaw";
+        cursor: "cursor";
+        "generic-mcp": "generic-mcp";
+    }>>;
+    source: z.ZodString;
+    tokenUtility: z.ZodString;
+    auditNotes: z.ZodArray<z.ZodString>;
+    operations: z.ZodArray<z.ZodString>;
+    tests: z.ZodArray<z.ZodString>;
+    policy: z.ZodObject<{
+        defaultMode: z.ZodEnum<{
+            "read-only": "read-only";
+            "approval-required": "approval-required";
+            "live-execution": "live-execution";
+        }>;
+        requiresApproval: z.ZodBoolean;
+        networkAccess: z.ZodBoolean;
+        walletWrite: z.ZodBoolean;
+        secrets: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        allowedChains: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        maxSpendUsd: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        sessionLimitMinutes: z.ZodDefault<z.ZodNumber>;
+        humanReadableRule: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type SkillRisk = z.infer<typeof riskSchema>;
+export type ExecutionMode = z.infer<typeof executionModeSchema>;
+export type Permission = z.infer<typeof permissionSchema>;
+export type SkillPolicy = z.infer<typeof policySchema>;
+export type SkillDefinition = z.infer<typeof skillDefinitionSchema>;
+export declare function assertSkillDefinition(value: unknown): SkillDefinition;
+export declare function validateSafetyRules(skill: SkillDefinition): string[];

package/dist/schema.js

@@ -0,0 +1,73 @@
+import { z } from "zod";
+export const riskSchema = z.enum(["low", "medium", "high", "critical"]);
+export const executionModeSchema = z.enum(["read-only", "approval-required", "live-execution"]);
+export const permissionSchema = z.enum([
+    "network",
+    "market-data",
+    "wallet-read",
+    "wallet-signature",
+    "transaction-preview",
+    "trading",
+    "api-key",
+    "notifications",
+    "contract-call",
+    "filesystem-read",
+    "filesystem-write",
+    "secrets-read",
+    "paid-api",
+    "governance",
+    "browser"
+]);
+export const policySchema = z.object({
+    defaultMode: executionModeSchema,
+    requiresApproval: z.boolean(),
+    networkAccess: z.boolean(),
+    walletWrite: z.boolean(),
+    secrets: z.array(z.string()).default([]),
+    allowedChains: z.array(z.string()).default([]),
+    maxSpendUsd: z.number().nonnegative().nullable().default(null),
+    sessionLimitMinutes: z.number().int().positive().default(30),
+    humanReadableRule: z.string().min(12)
+});
+export const skillDefinitionSchema = z.object({
+    id: z.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/),
+    title: z.string().min(3),
+    category: z.string().min(3),
+    summary: z.string().min(24),
+    useWhen: z.string().min(24),
+    chains: z.array(z.string()).min(1),
+    protocols: z.array(z.string()).min(1),
+    risk: riskSchema,
+    executionMode: executionModeSchema,
+    permissions: z.array(permissionSchema).min(1),
+    installTargets: z.array(z.enum(["codex", "claude", "openclaw", "cursor", "generic-mcp"])).min(1),
+    source: z.string().url(),
+    tokenUtility: z.string().min(12),
+    auditNotes: z.array(z.string()).min(2),
+    operations: z.array(z.string()).min(3),
+    tests: z.array(z.string()).min(2),
+    policy: policySchema
+});
+export function assertSkillDefinition(value) {
+    return skillDefinitionSchema.parse(value);
+}
+export function validateSafetyRules(skill) {
+    const findings = [];
+    const moneyMoving = skill.permissions.some((permission) => ["trading", "wallet-signature", "contract-call", "paid-api"].includes(permission));
+    if (moneyMoving && skill.executionMode !== "approval-required") {
+        findings.push("Money-moving skills must use approval-required mode.");
+    }
+    if (moneyMoving && !skill.policy.requiresApproval) {
+        findings.push("Money-moving skills must require human approval.");
+    }
+    if (skill.risk === "critical" && !skill.policy.requiresApproval) {
+        findings.push("Critical skills must require approval.");
+    }
+    if (skill.policy.walletWrite && !skill.permissions.includes("wallet-signature")) {
+        findings.push("walletWrite policies must include wallet-signature permission.");
+    }
+    if (skill.permissions.includes("secrets-read") && skill.policy.secrets.length === 0) {
+        findings.push("secrets-read permissions must declare expected secret names.");
+    }
+    return findings;
+}

package/dist/skillRegistry.d.ts

@@ -0,0 +1,99 @@
+import { SkillDefinition } from "./schema.js";
+export declare const skills: SkillDefinition[];
+export declare function getSkillById(id: string): {
+    id: string;
+    title: string;
+    category: string;
+    summary: string;
+    useWhen: string;
+    chains: string[];
+    protocols: string[];
+    risk: "low" | "medium" | "high" | "critical";
+    executionMode: "read-only" | "approval-required" | "live-execution";
+    permissions: ("network" | "market-data" | "wallet-read" | "wallet-signature" | "transaction-preview" | "trading" | "api-key" | "notifications" | "contract-call" | "filesystem-read" | "filesystem-write" | "secrets-read" | "paid-api" | "governance" | "browser")[];
+    installTargets: ("codex" | "claude" | "openclaw" | "cursor" | "generic-mcp")[];
+    source: string;
+    tokenUtility: string;
+    auditNotes: string[];
+    operations: string[];
+    tests: string[];
+    policy: {
+        defaultMode: "read-only" | "approval-required" | "live-execution";
+        requiresApproval: boolean;
+        networkAccess: boolean;
+        walletWrite: boolean;
+        secrets: string[];
+        allowedChains: string[];
+        maxSpendUsd: number | null;
+        sessionLimitMinutes: number;
+        humanReadableRule: string;
+    };
+} | undefined;
+export declare function getSkillsByChain(chain: string): {
+    id: string;
+    title: string;
+    category: string;
+    summary: string;
+    useWhen: string;
+    chains: string[];
+    protocols: string[];
+    risk: "low" | "medium" | "high" | "critical";
+    executionMode: "read-only" | "approval-required" | "live-execution";
+    permissions: ("network" | "market-data" | "wallet-read" | "wallet-signature" | "transaction-preview" | "trading" | "api-key" | "notifications" | "contract-call" | "filesystem-read" | "filesystem-write" | "secrets-read" | "paid-api" | "governance" | "browser")[];
+    installTargets: ("codex" | "claude" | "openclaw" | "cursor" | "generic-mcp")[];
+    source: string;
+    tokenUtility: string;
+    auditNotes: string[];
+    operations: string[];
+    tests: string[];
+    policy: {
+        defaultMode: "read-only" | "approval-required" | "live-execution";
+        requiresApproval: boolean;
+        networkAccess: boolean;
+        walletWrite: boolean;
+        secrets: string[];
+        allowedChains: string[];
+        maxSpendUsd: number | null;
+        sessionLimitMinutes: number;
+        humanReadableRule: string;
+    };
+}[];
+export declare function getRegistryStats(): {
+    totalSkills: number;
+    baseSkills: number;
+    criticalSkills: number;
+    approvalRequired: number;
+    readOnly: number;
+    chains: string[];
+};
+export declare function validateRegistry(): {
+    ok: boolean;
+    findings: string[];
+    stats: {
+        totalSkills: number;
+        baseSkills: number;
+        criticalSkills: number;
+        approvalRequired: number;
+        readOnly: number;
+        chains: string[];
+    };
+};
+export declare function toSkillMarkdown(skill: SkillDefinition): string;
+export declare function toPolicyJson(skill: SkillDefinition): string;
+export declare function summarizeSkill(skill: SkillDefinition): {
+    id: string;
+    title: string;
+    category: string;
+    summary: string;
+    useWhen: string;
+    chains: string[];
+    protocols: string[];
+    risk: "low" | "medium" | "high" | "critical";
+    executionMode: "read-only" | "approval-required" | "live-execution";
+    permissions: ("network" | "market-data" | "wallet-read" | "wallet-signature" | "transaction-preview" | "trading" | "api-key" | "notifications" | "contract-call" | "filesystem-read" | "filesystem-write" | "secrets-read" | "paid-api" | "governance" | "browser")[];
+    tokenUtility: string;
+    auditNotes: string[];
+    operations: string[];
+    installCommand: string;
+    source: string;
+};