signet-agent 0.1.0

package/dist/detect-framework.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Framework detection utility — detects installed MCP hosts and frameworks.
+ */
+export interface DetectedHost {
+    name: string;
+    configPath: string;
+    exists: boolean;
+}
+export declare function detectMcpHosts(): DetectedHost[];
+export declare function detectInstalledHosts(): DetectedHost[];
+export declare function detectPythonVersion(): string | null;
+export type Framework = "openclaw" | "mcp" | "python" | "rest" | "unknown";
+export declare function detectFramework(): Framework;

package/dist/detect-framework.js

@@ -0,0 +1,74 @@
+/**
+ * Framework detection utility — detects installed MCP hosts and frameworks.
+ */
+import { existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+export function detectMcpHosts() {
+    const home = homedir();
+    const hosts = [
+        {
+            name: "Claude Code",
+            configPath: join(home, ".claude", "mcp_config.json"),
+            exists: existsSync(join(home, ".claude", "mcp_config.json")),
+        },
+        {
+            name: "Cursor (global)",
+            configPath: join(home, ".cursor", "mcp.json"),
+            exists: existsSync(join(home, ".cursor", "mcp.json")),
+        },
+        {
+            name: "Cursor (project)",
+            configPath: join(process.cwd(), ".cursor", "mcp.json"),
+            exists: existsSync(join(process.cwd(), ".cursor", "mcp.json")),
+        },
+        {
+            name: "Windsurf",
+            configPath: join(home, ".windsurf", "mcp.json"),
+            exists: existsSync(join(home, ".windsurf", "mcp.json")),
+        },
+        {
+            name: "Cline",
+            configPath: join(home, ".cline", "mcp_config.json"),
+            exists: existsSync(join(home, ".cline", "mcp_config.json")),
+        },
+    ];
+    return hosts;
+}
+export function detectInstalledHosts() {
+    return detectMcpHosts().filter((h) => {
+        if (h.exists)
+            return true;
+        const dir = h.configPath.replace(/[/\\][^/\\]+$/, "");
+        return existsSync(dir);
+    });
+}
+export function detectPythonVersion() {
+    const { execSync } = require("child_process");
+    try {
+        const version = execSync("python3 --version 2>/dev/null || python --version 2>/dev/null", {
+            encoding: "utf8",
+        }).trim();
+        return version.replace("Python ", "");
+    }
+    catch {
+        return null;
+    }
+}
+export function detectFramework() {
+    const hosts = detectMcpHosts();
+    const hasMcpHost = hosts.some((h) => h.exists);
+    if (existsSync(join(process.cwd(), ".openclaw")) || existsSync(join(process.cwd(), "openclaw.json"))) {
+        return "openclaw";
+    }
+    if (hasMcpHost) {
+        return "mcp";
+    }
+    const pyVersion = detectPythonVersion();
+    if (pyVersion) {
+        const [major, minor] = pyVersion.split(".").map(Number);
+        if (major >= 3 && minor >= 10)
+            return "python";
+    }
+    return "unknown";
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+/**
+ * Signet CLI: init, start, stop, status, update, setup-mcp, setup-python, setup-openclaw.
+ * Usage: npx signet <command> [options]
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,356 @@
+#!/usr/bin/env node
+/**
+ * Signet CLI: init, start, stop, status, update, setup-mcp, setup-python, setup-openclaw.
+ * Usage: npx signet <command> [options]
+ */
+import { createInterface } from "readline";
+import { spawn, execSync } from "child_process";
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { createRequire } from "module";
+const require = createRequire(import.meta.url);
+const DEFAULT_DAEMON_URL = "http://127.0.0.1:8766";
+const DAEMON_URL = process.env.SIGNET_DAEMON_URL ?? DEFAULT_DAEMON_URL;
+const DEFAULT_DATA_DIR = join(homedir(), ".Signet");
+const DATA_DIR = process.env.SIGNET_DATA_DIR ?? DEFAULT_DATA_DIR;
+const PID_FILE = join(DATA_DIR, "signet.pid");
+const CONFIG_FILE = join(DATA_DIR, "config.json");
+const DIRECTORY_API_URL = process.env.DIRECTORY_API_URL ?? "https://api.onsignet.com";
+const DIRECTORY_WEB_URL = process.env.DIRECTORY_WEB_URL ?? "https://onsignet.com";
+function loadConfig() {
+    if (!existsSync(CONFIG_FILE))
+        return {};
+    try {
+        return JSON.parse(readFileSync(CONFIG_FILE, "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+function saveConfig(cfg) {
+    if (!existsSync(DATA_DIR))
+        mkdirSync(DATA_DIR, { recursive: true });
+    writeFileSync(CONFIG_FILE, JSON.stringify(cfg, null, 2) + "\n", "utf8");
+}
+function question(rl, prompt) {
+    return new Promise((resolve) => {
+        rl.question(prompt, (answer) => resolve(answer.trim()));
+    });
+}
+async function checkDaemon() {
+    try {
+        const res = await fetch(`${DAEMON_URL.replace(/\/$/, "")}/status`, { signal: AbortSignal.timeout(5000) });
+        if (!res.ok)
+            return { error: `Daemon returned ${res.status}` };
+        const data = (await res.json());
+        if (!data.connected)
+            return { error: "Daemon is not connected to the relay. Connect to the relay first." };
+        return { nodeId: data.nodeId, version: data.version };
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return { error: `Cannot reach Signet daemon at ${DAEMON_URL}: ${msg}\n\nStart the daemon first:\n  cd packages/daemon && npm start\n\nOr install it:\n  npm install -g @signet/daemon` };
+    }
+}
+async function registerProfile(body, authToken) {
+    try {
+        const headers = { "Content-Type": "application/json" };
+        if (authToken)
+            headers["Authorization"] = `Bearer ${authToken}`;
+        const res = await fetch(`${DAEMON_URL.replace(/\/$/, "")}/directory/agents`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(15000),
+        });
+        const data = (await res.json());
+        if (!res.ok) {
+            if (res.status === 403 && data.upgrade_url) {
+                return { error: `${data.error}\n\nPurchase extra slots at: ${DIRECTORY_WEB_URL}${data.upgrade_url}` };
+            }
+            return { error: data.error ?? `HTTP ${res.status}` };
+        }
+        return { profileUrl: data.profileUrl, agent: data.agent };
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return { error: msg };
+    }
+}
+async function cmdStatus() {
+    const res = await fetch(`${DAEMON_URL.replace(/\/$/, "")}/status`, { signal: AbortSignal.timeout(5000) });
+    if (!res.ok) {
+        console.error("Daemon returned", res.status);
+        process.exit(1);
+    }
+    const data = (await res.json());
+    console.log("Relay:", data.connected ? "connected" : "disconnected");
+    console.log("NodeId:", data.nodeId ?? "—");
+    if (data.version)
+        console.log("Version:", data.version);
+    if (data.agentStatus != null) {
+        console.log("Agent:", data.agentStatus, data.agentPid != null ? `(pid ${data.agentPid})` : "");
+        if (data.agentRestartCount != null && data.agentRestartCount > 0) {
+            console.log("Agent restarts:", data.agentRestartCount);
+        }
+    }
+    const config = loadConfig();
+    if (config.profileUrl)
+        console.log("Profile:", config.profileUrl);
+    if (config.framework)
+        console.log("Framework:", config.framework);
+}
+function cmdStop() {
+    if (!existsSync(PID_FILE)) {
+        console.error("No PID file found. Is the daemon running?");
+        process.exit(1);
+    }
+    const pid = parseInt(readFileSync(PID_FILE, "utf8").trim(), 10);
+    if (!Number.isInteger(pid)) {
+        console.error("Invalid PID file.");
+        process.exit(1);
+    }
+    try {
+        process.kill(pid, "SIGTERM");
+        console.log("Sent SIGTERM to daemon (pid", pid + ").");
+    }
+    catch (e) {
+        console.error("Failed to stop daemon:", e instanceof Error ? e.message : e);
+        process.exit(1);
+    }
+}
+function cmdStart() {
+    let daemonMain;
+    try {
+        daemonMain = require.resolve("@signet/daemon");
+    }
+    catch {
+        console.error("Signet daemon not found. Install @signet/daemon or run from the Signet repo (packages/daemon).");
+        process.exit(1);
+    }
+    const child = spawn(process.execPath, [daemonMain], {
+        stdio: "inherit",
+        env: process.env,
+    });
+    child.on("exit", (code, signal) => {
+        process.exit(code ?? (signal === "SIGTERM" ? 0 : 1));
+    });
+}
+async function cmdUpdate() {
+    console.log("Checking for updates...\n");
+    let currentVersion = "unknown";
+    try {
+        const daemonStatus = await checkDaemon();
+        if (daemonStatus.version)
+            currentVersion = daemonStatus.version;
+    }
+    catch {
+        // Daemon may not be running
+    }
+    try {
+        const latestRes = await fetch(`${DIRECTORY_API_URL.replace(/\/$/, "")}/version`, { signal: AbortSignal.timeout(10000) });
+        if (latestRes.ok) {
+            const { version: latest, min_version: minVersion } = (await latestRes.json());
+            if (latest) {
+                console.log(`  Current: ${currentVersion}`);
+                console.log(`  Latest:  ${latest}`);
+                if (minVersion)
+                    console.log(`  Minimum: ${minVersion}`);
+                if (currentVersion === latest) {
+                    console.log("\nAlready up to date.");
+                    return;
+                }
+            }
+        }
+    }
+    catch {
+        console.log("  Could not check latest version; updating anyway.");
+    }
+    console.log("\nUpdating @signet/daemon...");
+    try {
+        execSync("npm install -g @signet/daemon@latest", { stdio: "inherit" });
+        console.log("\nUpdate complete. Restart the daemon to apply:");
+        console.log("  signet stop && signet start");
+    }
+    catch (e) {
+        console.error("Update failed:", e instanceof Error ? e.message : e);
+        console.error("\nTry manually: npm install -g @signet/daemon@latest");
+        process.exit(1);
+    }
+}
+async function cmdInit() {
+    const nodeVersion = process.version.slice(1).split(".").map(Number)[0];
+    if (nodeVersion < 18) {
+        console.error("Signet CLI requires Node.js 18 or later.");
+        process.exit(1);
+    }
+    // Parse --framework flag
+    const frameworkArg = process.argv.find((a) => a.startsWith("--framework"));
+    let framework;
+    if (frameworkArg) {
+        const value = frameworkArg.includes("=") ? frameworkArg.split("=")[1] : process.argv[process.argv.indexOf(frameworkArg) + 1];
+        if (["openclaw", "mcp", "python", "rest"].includes(value)) {
+            framework = value;
+        }
+    }
+    console.log("Signet — register your agent on the directory\n");
+    const daemonStatus = await checkDaemon();
+    if (daemonStatus.error) {
+        console.error(daemonStatus.error);
+        process.exit(1);
+    }
+    console.log(`  Daemon is running`);
+    console.log(`  Node ID: ${daemonStatus.nodeId}`);
+    if (daemonStatus.version)
+        console.log(`  Version: ${daemonStatus.version}`);
+    console.log();
+    const config = loadConfig();
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    let authToken = config.authToken;
+    if (!authToken) {
+        const tokenInput = await question(rl, "Auth token (paste from dashboard, or press Enter to skip): ");
+        if (tokenInput)
+            authToken = tokenInput;
+    }
+    const name = await question(rl, "Agent name (e.g. My Research Assistant): ") || "My Agent";
+    const description = await question(rl, "Short description (optional): ");
+    const domainsInput = await question(rl, "Capability domains, comma-separated (e.g. research, scheduling) (optional): ");
+    const capabilities = domainsInput
+        ? domainsInput.split(",").map((d) => ({ domain: d.trim() })).filter((c) => c.domain.length > 0)
+        : undefined;
+    // Framework selection if not provided via flag
+    if (!framework) {
+        const frameworkInput = await question(rl, "Framework (openclaw / mcp / python / rest) [press Enter to auto-detect]: ");
+        if (frameworkInput && ["openclaw", "mcp", "python", "rest"].includes(frameworkInput)) {
+            framework = frameworkInput;
+        }
+    }
+    rl.close();
+    console.log("\nRegistering with the directory...");
+    const result = await registerProfile({ name, description: description || undefined, capabilities, framework }, authToken);
+    if (result.error) {
+        console.error("\nRegistration failed:", result.error);
+        process.exit(1);
+    }
+    const profilePath = result.profileUrl ?? `/agents/${result.agent?.node_id ?? "your-agent"}`;
+    const profileUrl = profilePath.startsWith("http") ? profilePath : `${DIRECTORY_WEB_URL}${profilePath.startsWith("/") ? "" : "/"}${profilePath}`;
+    saveConfig({
+        ...config,
+        nodeId: daemonStatus.nodeId,
+        authToken: authToken || config.authToken,
+        registeredAt: new Date().toISOString(),
+        profileUrl,
+        framework: framework || config.framework,
+    });
+    console.log("\n  Done! Your agent is live on the directory.");
+    console.log(`  Profile: ${profileUrl}`);
+    console.log(`  Daemon UI: ${DAEMON_URL}`);
+    // Run framework-specific setup if --framework was specified
+    if (framework === "mcp") {
+        console.log("\n  Running MCP setup...");
+        const { cmdSetupMcp } = await import("./setup-mcp.js");
+        await cmdSetupMcp();
+    }
+    else if (framework === "python") {
+        console.log("\n  Running Python setup...");
+        const { cmdSetupPython } = await import("./setup-python.js");
+        await cmdSetupPython();
+    }
+    else if (framework === "openclaw") {
+        console.log("\n  Running OpenClaw setup...");
+        await cmdSetupOpenclaw();
+    }
+    console.log("\n  Share the profile link so others can find and connect with your agent.");
+}
+async function cmdSetupOpenclaw() {
+    console.log("Signet OpenClaw Setup\n");
+    try {
+        const res = await fetch(`${DAEMON_URL.replace(/\/$/, "")}/status`, { signal: AbortSignal.timeout(5000) });
+        if (!res.ok) {
+            console.error("Daemon not responding. Start it first: npx signet start");
+            process.exit(1);
+        }
+        console.log("  Daemon running ✓");
+    }
+    catch {
+        console.error(`Cannot reach daemon at ${DAEMON_URL}. Start it first: npx signet start`);
+        process.exit(1);
+    }
+    console.log("  OpenClaw skill files are available at:");
+    console.log(`    Skill JSON: ${DAEMON_URL}/adapters/openclaw/skill.json`);
+    console.log(`    SKILL.md:   ${DAEMON_URL}/adapters/openclaw/skill.md`);
+    console.log("\n  To install the skill, add the Signet skill to your OpenClaw configuration.");
+    console.log("  The daemon bridge will forward messages between OpenClaw and the Signet network.");
+    const config = loadConfig();
+    saveConfig({ ...config, framework: "openclaw" });
+    console.log("\n  Framework set to: openclaw");
+}
+async function main() {
+    const cmd = process.argv[2] ?? "init";
+    switch (cmd) {
+        case "start":
+            cmdStart();
+            return;
+        case "stop":
+            cmdStop();
+            return;
+        case "status":
+            await cmdStatus();
+            return;
+        case "init":
+            await cmdInit();
+            return;
+        case "update":
+            await cmdUpdate();
+            return;
+        case "setup-mcp": {
+            const { cmdSetupMcp } = await import("./setup-mcp.js");
+            await cmdSetupMcp();
+            return;
+        }
+        case "setup-python": {
+            const { cmdSetupPython } = await import("./setup-python.js");
+            await cmdSetupPython();
+            return;
+        }
+        case "setup-openclaw":
+            await cmdSetupOpenclaw();
+            return;
+        case "serve-mcp": {
+            const { execSync: exec } = await import("child_process");
+            try {
+                exec("node adapters/mcp/dist/index.js", { stdio: "inherit", cwd: join(__dirname, "..", "..") });
+            }
+            catch {
+                console.error("Failed to start MCP server. Build it first: cd adapters/mcp && npm run build");
+            }
+            return;
+        }
+        case "--help":
+        case "-h":
+        case "help":
+            console.log("Usage: signet <command>\n");
+            console.log("Commands:");
+            console.log("  init [--framework <name>]  Register your agent on the directory");
+            console.log("  start                      Start the Signet daemon");
+            console.log("  stop                       Stop the Signet daemon");
+            console.log("  status                     Show daemon and agent status");
+            console.log("  update                     Update the daemon to the latest version");
+            console.log("  setup-mcp                  Configure MCP hosts (Cursor, Claude Code, etc.)");
+            console.log("  setup-python               Set up Python client (pip install + quickstart)");
+            console.log("  setup-openclaw             Configure OpenClaw skill adapter");
+            console.log("  serve-mcp                  Start the MCP server process");
+            console.log("  help                       Show this help message");
+            console.log("\nFrameworks: openclaw, mcp, python, rest");
+            return;
+        default:
+            console.error("Unknown command:", cmd);
+            console.error("Run 'signet help' for usage.");
+            process.exit(1);
+    }
+}
+main().catch((e) => {
+    console.error(e);
+    process.exit(1);
+});

package/dist/setup-mcp.d.ts

@@ -0,0 +1,4 @@
+/**
+ * `signet setup-mcp` — auto-configure MCP hosts to use Signet tools.
+ */
+export declare function cmdSetupMcp(): Promise<void>;

package/dist/setup-mcp.js

@@ -0,0 +1,121 @@
+/**
+ * `signet setup-mcp` — auto-configure MCP hosts to use Signet tools.
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join, resolve } from "path";
+import { detectMcpHosts } from "./detect-framework.js";
+const DAEMON_URL = process.env.SIGNET_DAEMON_URL ?? "http://127.0.0.1:8766";
+function findMcpServerPath() {
+    const candidates = [
+        join(__dirname, "..", "..", "adapters", "mcp", "dist", "index.js"),
+        join(process.cwd(), "adapters", "mcp", "dist", "index.js"),
+    ];
+    for (const c of candidates) {
+        const resolved = resolve(c);
+        if (existsSync(resolved))
+            return resolved;
+    }
+    // Fall back: try require resolution
+    try {
+        const path = require.resolve("@signet/mcp-server");
+        return path;
+    }
+    catch {
+        // Assume it's in the standard monorepo location relative to CLI
+    }
+    return resolve(join(__dirname, "..", "..", "adapters", "mcp", "dist", "index.js"));
+}
+function addToMcpConfig(configPath, serverPath) {
+    let config = {};
+    if (existsSync(configPath)) {
+        try {
+            config = JSON.parse(readFileSync(configPath, "utf8"));
+        }
+        catch {
+            config = {};
+        }
+    }
+    const servers = (config.mcpServers ?? {});
+    if (servers.signet) {
+        return false; // Already configured
+    }
+    servers.signet = {
+        command: "node",
+        args: [serverPath],
+        env: {},
+    };
+    config.mcpServers = servers;
+    const dir = configPath.replace(/[/\\][^/\\]+$/, "");
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf8");
+    return true;
+}
+export async function cmdSetupMcp() {
+    console.log("Signet MCP Setup\n");
+    // 1. Check daemon
+    try {
+        const res = await fetch(`${DAEMON_URL.replace(/\/$/, "")}/status`, { signal: AbortSignal.timeout(5000) });
+        if (!res.ok) {
+            console.error(`Daemon returned HTTP ${res.status}. Start the daemon first: npx signet start`);
+            process.exit(1);
+        }
+        const data = (await res.json());
+        console.log(`  Daemon running: ${data.nodeId}`);
+        if (!data.connected) {
+            console.warn("  Warning: daemon is not connected to relay yet.");
+        }
+    }
+    catch {
+        console.error(`Cannot reach daemon at ${DAEMON_URL}.\nStart it first: npx signet start`);
+        process.exit(1);
+    }
+    // 2. Find MCP server binary
+    const serverPath = findMcpServerPath();
+    console.log(`  MCP server: ${serverPath}`);
+    if (!existsSync(serverPath)) {
+        console.warn(`  Warning: MCP server not found at ${serverPath}. Build it first: cd adapters/mcp && npm run build`);
+    }
+    // 3. Detect and configure MCP hosts
+    const hosts = detectMcpHosts();
+    const detected = hosts.filter((h) => {
+        const dir = h.configPath.replace(/[/\\][^/\\]+$/, "");
+        return h.exists || existsSync(dir);
+    });
+    if (detected.length === 0) {
+        console.log("\n  No MCP-compatible hosts detected (Claude Code, Cursor, Windsurf, Cline).");
+        console.log("  Install one, then run `npx signet setup-mcp` again.");
+        console.log("\n  Manual configuration:");
+        console.log(`  Add this to your MCP config file:`);
+        console.log(`  {`);
+        console.log(`    "mcpServers": {`);
+        console.log(`      "signet": {`);
+        console.log(`        "command": "node",`);
+        console.log(`        "args": ["${serverPath}"]`);
+        console.log(`      }`);
+        console.log(`    }`);
+        console.log(`  }`);
+        return;
+    }
+    console.log(`\n  Detected ${detected.length} MCP host(s):\n`);
+    let configured = 0;
+    for (const host of detected) {
+        const added = addToMcpConfig(host.configPath, serverPath);
+        if (added) {
+            console.log(`    ✓ ${host.name} — configured (${host.configPath})`);
+            configured++;
+        }
+        else {
+            console.log(`    · ${host.name} — already configured`);
+        }
+    }
+    console.log();
+    if (configured > 0) {
+        console.log(`  Signet tools added to ${configured} host(s).`);
+        console.log("  Restart your editor to load the new tools.");
+    }
+    else {
+        console.log("  All detected hosts already have Signet configured.");
+    }
+    console.log('\n  Try asking your AI: "Search for compute providers on Signet."');
+}

package/dist/setup-python.d.ts

@@ -0,0 +1,4 @@
+/**
+ * `signet setup-python` — guide Python developers through Signet setup.
+ */
+export declare function cmdSetupPython(): Promise<void>;

package/dist/setup-python.js

@@ -0,0 +1,90 @@
+/**
+ * `signet setup-python` — guide Python developers through Signet setup.
+ */
+import { existsSync, writeFileSync } from "fs";
+import { join } from "path";
+import { detectPythonVersion } from "./detect-framework.js";
+const QUICKSTART_SCRIPT = `#!/usr/bin/env python3
+"""Signet quickstart — verify your connection and discover agents."""
+
+import asyncio
+from signet import SignetClient
+
+
+async def main():
+    async with SignetClient() as client:
+        # Check connection
+        status = await client.status()
+        if status.connected:
+            print(f"✓ Connected to Signet network")
+            print(f"  Agent ID: {status.node_id}")
+            print(f"  Relay: {status.relay_url}")
+        else:
+            print("✗ Not connected. Is the daemon running? (npx signet start)")
+            return
+
+        # Search the directory
+        print("\\nSearching for agents on the network...")
+        agents = await client.discover(limit=5)
+
+        if agents:
+            print(f"\\nFound {len(agents)} agents:")
+            for a in agents:
+                caps = ", ".join(c.domain for c in a.capabilities) if a.capabilities else "general"
+                print(f"  - {a.name} [{caps}]")
+        else:
+            print("\\nNo agents found yet. The network is just getting started!")
+
+        print("\\n✓ Signet Python client is working. You're ready to build.")
+        print("  See examples/ in the signet-agent package for common patterns.")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+`;
+export async function cmdSetupPython() {
+    console.log("Signet Python Setup\n");
+    // 1. Check Python version
+    const version = detectPythonVersion();
+    if (!version) {
+        console.error("  Python not found. Install Python 3.10+ first.");
+        process.exit(1);
+    }
+    const [major, minor] = version.split(".").map(Number);
+    if (major < 3 || (major === 3 && minor < 10)) {
+        console.error(`  Python ${version} found, but Signet requires Python 3.10+.`);
+        console.error("  Upgrade: https://python.org/downloads/");
+        process.exit(1);
+    }
+    console.log(`  Python ${version} ✓`);
+    // 2. Print install commands
+    console.log("\n  Install the Signet Python package:\n");
+    console.log("    pip install signet-agent                    # Core client");
+    console.log("    pip install signet-agent[langchain]         # + LangChain bindings");
+    console.log("    pip install signet-agent[crewai]            # + CrewAI bindings");
+    console.log("    pip install signet-agent[all]               # Everything");
+    // 3. Generate quickstart script
+    const quickstartPath = join(process.cwd(), "signet_quickstart.py");
+    if (!existsSync(quickstartPath)) {
+        writeFileSync(quickstartPath, QUICKSTART_SCRIPT, "utf8");
+        console.log(`\n  Generated: ${quickstartPath}`);
+    }
+    else {
+        console.log(`\n  Quickstart script already exists: ${quickstartPath}`);
+    }
+    // 4. Verify daemon
+    const daemonUrl = process.env.SIGNET_DAEMON_URL ?? "http://127.0.0.1:8766";
+    try {
+        const res = await fetch(`${daemonUrl.replace(/\/$/, "")}/status`, { signal: AbortSignal.timeout(5000) });
+        if (res.ok) {
+            console.log("  Daemon running ✓");
+        }
+    }
+    catch {
+        console.log("\n  Note: Daemon not running. Start it first: npx signet start");
+    }
+    console.log("\n  Next steps:");
+    console.log("    1. pip install signet-agent");
+    console.log("    2. npx signet start           # Start daemon if not running");
+    console.log("    3. python signet_quickstart.py # Verify connection");
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "signet-agent",
+  "version": "0.1.0",
+  "description": "Signet CLI — register your agent on the Signet directory",
+  "license": "MIT",
+  "type": "module",
+  "files": [
+    "dist/",
+    "README.md"
+  ],
+  "bin": {
+    "signet": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "init": "node dist/index.js"
+  },
+  "dependencies": {
+    "@signet/daemon": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "typescript": "^5.3.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}