@indexnetwork/cli 0.9.0 → 0.9.2

package/README.md

@@ -189,11 +189,14 @@ index opportunity discover "collaborate on open-source LLM tooling" --target <us
 
 ### Scenario 3: Introduction
 
-Introduce two people you think should connect. You become the introducer — both parties see you as the connector.
+Introduce two people you think should connect. You become the introducer — both parties see you as the connector. The CLI automatically finds shared networks, gathers profiles and intents, then creates the introduction.
 
 ```bash
 # Introduce two users to each other
 index opportunity discover --introduce <user-id-a> <user-id-b>
+
+# Provide a reason for the introduction
+index opportunity discover --introduce <user-id-a> <user-id-b> "both working on privacy-preserving ML"
 ```
 
 ### Scenario 4: Review and act
@@ -277,6 +280,7 @@ cli/
     contact.command.ts         Contact subcommand handlers
     scrape.command.ts          URL scraping command handler
     sync.command.ts            Context sync command handler
+    onboarding.command.ts      Onboarding command handler
     output/                    Terminal formatting, colors, markdown renderer
     api.client.ts              Typed HTTP client for the protocol API
     auth.store.ts              Credential persistence (~/.index/credentials.json)

package/dist/index.js

@@ -267,11 +267,6 @@ class ApiClient {
     const body = await res.json();
     return body.user;
   }
-  async syncProfile() {
-    const res = await this.post("/api/profiles/sync");
-    const body = await res.json();
-    return body;
-  }
   async listOpportunities(opts) {
     const params = new URLSearchParams;
     if (opts?.status)
@@ -288,10 +283,6 @@ class ApiClient {
     const res = await this.get(`/api/opportunities/${id}`);
     return await res.json();
   }
-  async updateOpportunityStatus(id, status) {
-    const res = await this.patch(`/api/opportunities/${id}/status`, { status });
-    return await res.json();
-  }
   async streamChat(params) {
     const res = await fetch(`${this.baseUrl}/api/chat/stream`, {
       method: "POST",
@@ -327,14 +318,6 @@ class ApiClient {
     const body = await res.json();
     return body.intent;
   }
-  async processIntent(content) {
-    const res = await this.post("/api/intents/process", { content });
-    return await res.json();
-  }
-  async archiveIntent(id) {
-    const res = await this.patch(`/api/intents/${id}/archive`);
-    return await res.json();
-  }
   async listNetworks() {
     const res = await this.get("/api/indexes");
     const body = await res.json();
@@ -456,20 +439,6 @@ class ApiClient {
     }
     return res;
   }
-  async patch(path, body) {
-    const res = await fetch(`${this.baseUrl}${path}`, {
-      method: "PATCH",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.token}`
-      },
-      ...body !== undefined ? { body: JSON.stringify(body) } : {}
-    });
-    if (!res.ok) {
-      await this.handleError(res);
-    }
-    return res;
-  }
   async del(path) {
     const res = await fetch(`${this.baseUrl}${path}`, {
       method: "DELETE",
@@ -1354,7 +1323,7 @@ function messageList(messages) {
 // src/profile.command.ts
 async function handleProfile(client, subcommand, positionals, options = {}) {
   if (subcommand === "create") {
-    await profileCreate(client, options);
+    await profileCreate(client, options, options?.json);
     return;
   }
   if (subcommand === "update") {
@@ -1363,11 +1332,11 @@ async function handleProfile(client, subcommand, positionals, options = {}) {
       error("Usage: index profile update <action> [--details <text>]", 1);
       return;
     }
-    await profileUpdate(client, action, options.details);
+    await profileUpdate(client, action, options.details, options?.json);
     return;
   }
   if (subcommand === "sync") {
-    await profileSync(client);
+    await profileSync(client, options?.json);
     return;
   }
   if (subcommand === "show") {
@@ -1376,7 +1345,7 @@ async function handleProfile(client, subcommand, positionals, options = {}) {
       error("Usage: index profile show <user-id>", 1);
       return;
     }
-    await profileShow(client, userId);
+    await profileShow(client, userId, options?.json);
     return;
   }
   if (subcommand === "search") {
@@ -1408,26 +1377,63 @@ async function handleProfile(client, subcommand, positionals, options = {}) {
     console.log();
     return;
   }
-  await profileMe(client);
+  await profileMe(client, options?.json);
 }
-async function profileMe(client) {
-  info("Loading your profile...");
+async function profileMe(client, json) {
+  if (!json) {
+    info("Loading your profile...");
+  }
   const me = await client.getMe();
   const user = await client.getUser(me.id);
+  if (json) {
+    console.log(JSON.stringify(user));
+    return;
+  }
   profileCard(user);
 }
-async function profileShow(client, userId) {
-  info("Loading profile...");
+async function profileShow(client, userId, json) {
+  if (!json) {
+    info("Loading profile...");
+  }
   const user = await client.getUser(userId);
+  if (json) {
+    console.log(JSON.stringify(user));
+    return;
+  }
   profileCard(user);
 }
-async function profileSync(client) {
-  info("Regenerating profile...");
-  await client.syncProfile();
+async function profileSync(client, json) {
+  if (!json)
+    info("Regenerating profile...");
+  const check = await client.callTool("read_user_profiles", {});
+  if (!check.success) {
+    if (json) {
+      console.log(JSON.stringify(check));
+      return;
+    }
+    error(check.error ?? "Failed to check profile status", 1);
+    return;
+  }
+  const hasProfile = check.data?.hasProfile;
+  let result;
+  if (hasProfile) {
+    result = await client.callTool("update_user_profile", { action: "regenerate" });
+  } else {
+    result = await client.callTool("create_user_profile", { confirm: true });
+  }
+  if (json) {
+    console.log(JSON.stringify(result));
+    return;
+  }
+  if (!result.success) {
+    error(result.error ?? "Profile regeneration failed", 1);
+    return;
+  }
   success("Profile regeneration triggered. It may take a moment to complete.");
 }
-async function profileCreate(client, options) {
-  info("Creating profile...");
+async function profileCreate(client, options, json) {
+  if (!json)
+    info("Creating profile...");
   const query = { confirm: true };
   if (options.linkedin)
     query.linkedinUrl = options.linkedin;
@@ -1436,18 +1442,27 @@ async function profileCreate(client, options) {
   if (options.twitter)
     query.twitterUrl = options.twitter;
   const result = await client.callTool("create_user_profile", query);
+  if (json) {
+    console.log(JSON.stringify(result));
+    return;
+  }
   if (!result.success) {
     error(result.error ?? "Profile creation failed", 1);
     return;
   }
   success("Profile created.");
 }
-async function profileUpdate(client, action, details) {
-  info("Updating profile...");
+async function profileUpdate(client, action, details, json) {
+  if (!json)
+    info("Updating profile...");
   const query = { action };
   if (details)
     query.details = details;
   const result = await client.callTool("update_user_profile", query);
+  if (json) {
+    console.log(JSON.stringify(result));
+    return;
+  }
   if (!result.success) {
     error(result.error ?? "Profile update failed", 1);
     return;
@@ -1513,16 +1528,23 @@ async function handleIntent(client, subcommand, options) {
         error("Missing content. Usage: index intent create <content>", 1);
         return;
       }
-      info("Processing signal...");
-      const result = await client.processIntent(options.intentContent);
+      if (!options.json)
+        info("Processing signal...");
+      const result = await client.callTool("create_intent", {
+        description: options.intentContent
+      });
       if (options.json) {
         console.log(JSON.stringify(result));
         return;
       }
-      success("Signal processed successfully.");
-      if (result.message) {
-        dim(`  ${result.message}`);
+      if (!result.success) {
+        error(result.error ?? "Failed to create signal", 1);
+        return;
       }
+      success("Signal created.");
+      const data = result.data;
+      if (data?.message)
+        dim(`  ${data.message}`);
       return;
     }
     case "update": {
@@ -1534,7 +1556,8 @@ async function handleIntent(client, subcommand, options) {
         error("Missing content. Usage: index intent update <id> <content>", 1);
         return;
       }
-      info("Updating signal...");
+      if (!options.json)
+        info("Updating signal...");
       const result = await client.callTool("update_intent", {
         intentId: options.intentId,
         newDescription: options.intentContent
@@ -1555,9 +1578,14 @@ async function handleIntent(client, subcommand, options) {
         error("Missing signal ID. Usage: index intent archive <id>", 1);
         return;
       }
-      await client.archiveIntent(options.intentId);
+      const intent = await client.getIntent(options.intentId);
+      const result = await client.callTool("delete_intent", { intentId: intent.id });
       if (options.json) {
-        console.log(JSON.stringify({ success: true }));
+        console.log(JSON.stringify(result));
+        return;
+      }
+      if (!result.success) {
+        error(result.error ?? "Failed to archive signal", 1);
         return;
       }
       success(`Signal ${options.intentId} archived.`);
@@ -1688,32 +1716,51 @@ async function handleOpportunity(client, subcommand, options) {
         error("Usage: index opportunity discover <query>", 1);
         return;
       }
-      info("Discovering opportunities...");
-      const toolQuery = {};
       if (options.introduce) {
-        toolQuery.mode = "introduction";
-        toolQuery.sourceUserId = options.introduce;
-        toolQuery.targetUserId = options.positionals?.[0];
+        const userA = options.introduce;
+        const userB = options.positionals?.[0];
+        if (!userB) {
+          error("Usage: index opportunity discover --introduce <userA> <userB>", 1);
+          return;
+        }
+        const hint = options.positionals?.slice(1).join(" ") || undefined;
+        await discoverIntroduction(client, userA, userB, hint, options.json);
       } else if (options.target) {
-        toolQuery.mode = "direct";
-        toolQuery.targetUserId = options.target;
-        toolQuery.searchQuery = query;
+        if (!options.json)
+          info("Discovering opportunities...");
+        const result = await client.callTool("create_opportunities", {
+          targetUserId: options.target,
+          searchQuery: query
+        });
+        if (options.json) {
+          console.log(JSON.stringify(result));
+          return;
+        }
+        if (!result.success) {
+          error(result.error ?? "Discovery failed", 1);
+          return;
+        }
+        success("Discovery complete.");
+        const data = result.data;
+        if (data?.message)
+          dim(`  ${data.message}`);
       } else {
-        toolQuery.searchQuery = query;
-      }
-      const result = await client.callTool("create_opportunities", toolQuery);
-      if (options.json) {
-        console.log(JSON.stringify(result));
-        return;
-      }
-      if (!result.success) {
-        error(result.error ?? "Discovery failed", 1);
-        return;
+        if (!options.json)
+          info("Discovering opportunities...");
+        const result = await client.callTool("create_opportunities", { searchQuery: query });
+        if (options.json) {
+          console.log(JSON.stringify(result));
+          return;
+        }
+        if (!result.success) {
+          error(result.error ?? "Discovery failed", 1);
+          return;
+        }
+        success("Discovery complete.");
+        const data = result.data;
+        if (data?.message)
+          dim(`  ${data.message}`);
       }
-      success("Discovery complete.");
-      const data = result.data;
-      if (data?.message)
-        dim(`  ${data.message}`);
       return;
     }
     default:
@@ -1740,13 +1787,94 @@ async function opportunityShow(client, id, json) {
   opportunityCard(opportunity);
 }
 async function opportunityStatusUpdate(client, id, status2, json) {
-  const result = await client.updateOpportunityStatus(id, status2);
+  const opportunity = await client.getOpportunity(id);
+  const result = await client.callTool("update_opportunity", {
+    opportunityId: opportunity.id,
+    status: status2
+  });
   if (json) {
     console.log(JSON.stringify(result));
     return;
   }
-  const label = status2 === "accepted" ? "accepted" : "rejected";
-  success(`Opportunity ${label}.`);
+  if (!result.success) {
+    error(result.error ?? `Failed to ${status2 === "accepted" ? "accept" : "reject"} opportunity`, 1);
+    return;
+  }
+  success(`Opportunity ${status2 === "accepted" ? "accepted" : "rejected"}.`);
+}
+async function discoverIntroduction(client, userA, userB, hint, json) {
+  info("Gathering data for introduction...");
+  const [membershipsA, membershipsB] = await Promise.all([
+    client.callTool("read_index_memberships", { userId: userA }),
+    client.callTool("read_index_memberships", { userId: userB })
+  ]);
+  if (!membershipsA.success || !membershipsB.success) {
+    const err = membershipsA.error ?? membershipsB.error ?? "Failed to read memberships";
+    if (json) {
+      console.log(JSON.stringify({ success: false, error: err }));
+      return;
+    }
+    error(err, 1);
+    return;
+  }
+  const indexesA = membershipsA.data?.memberships ?? membershipsA.data?.indexes ?? [];
+  const indexesB = membershipsB.data?.memberships ?? membershipsB.data?.indexes ?? [];
+  const idsA = new Set(indexesA.map((m) => m.indexId));
+  const shared = indexesB.filter((m) => idsA.has(m.indexId));
+  if (shared.length === 0) {
+    const err = "No shared indexes found between these users. They must be members of at least one common network.";
+    if (json) {
+      console.log(JSON.stringify({ success: false, error: err }));
+      return;
+    }
+    error(err, 1);
+    return;
+  }
+  const sharedIndexId = shared[0].indexId;
+  dim(`  Found shared network: ${sharedIndexId}`);
+  const [profileA, profileB, intentsA, intentsB] = await Promise.all([
+    client.callTool("read_user_profiles", { userId: userA }),
+    client.callTool("read_user_profiles", { userId: userB }),
+    client.callTool("read_intents", { userId: userA, indexId: sharedIndexId }),
+    client.callTool("read_intents", { userId: userB, indexId: sharedIndexId })
+  ]);
+  const extractProfile = (result2) => {
+    if (!result2.success || !result2.data)
+      return;
+    const d = result2.data;
+    if (d.profile)
+      return d.profile;
+    const profiles = d.profiles;
+    return profiles?.[0]?.profile;
+  };
+  const extractIntents = (result2) => {
+    if (!result2.success || !result2.data)
+      return;
+    const d = result2.data;
+    return d.intents?.map((i) => ({ intentId: i.intentId ?? i.id ?? "", payload: i.payload, summary: i.summary }));
+  };
+  const entities = [
+    { userId: userA, profile: extractProfile(profileA), intents: extractIntents(intentsA), indexId: sharedIndexId },
+    { userId: userB, profile: extractProfile(profileB), intents: extractIntents(intentsB), indexId: sharedIndexId }
+  ];
+  dim("  Profiles and intents gathered. Creating introduction...");
+  const result = await client.callTool("create_opportunities", {
+    partyUserIds: [userA, userB],
+    entities,
+    ...hint ? { hint } : {}
+  });
+  if (json) {
+    console.log(JSON.stringify(result));
+    return;
+  }
+  if (!result.success) {
+    error(result.error ?? "Introduction failed", 1);
+    return;
+  }
+  success("Introduction created.");
+  const data = result.data;
+  if (data?.message)
+    dim(`  ${data.message}`);
 }
 
 // src/network.command.ts
@@ -1770,46 +1898,54 @@ async function handleNetwork(client, subcommand, positionals, options) {
   }
   switch (subcommand) {
     case "list":
-      await networkList(client);
+      await networkList(client, options.json);
       return;
     case "create":
-      await networkCreate(client, positionals[0], options.prompt);
+      await networkCreate(client, positionals[0], options.prompt, options.json);
       return;
     case "show":
-      await networkShow(client, positionals[0]);
+      await networkShow(client, positionals[0], options.json);
       return;
     case "join":
-      await networkJoin(client, positionals[0]);
+      await networkJoin(client, positionals[0], options.json);
       return;
     case "leave":
-      await networkLeave(client, positionals[0]);
+      await networkLeave(client, positionals[0], options.json);
       return;
     case "update":
-      await networkUpdate(client, positionals[0], options);
+      await networkUpdate(client, positionals[0], options, options.json);
       return;
     case "delete":
-      await networkDelete(client, positionals[0]);
+      await networkDelete(client, positionals[0], options.json);
       return;
     case "invite":
-      await networkInvite(client, positionals[0], positionals[1]);
+      await networkInvite(client, positionals[0], positionals[1], options.json);
       return;
     default:
       error(`Unknown network subcommand: ${subcommand}`, 1);
   }
 }
-async function networkList(client) {
+async function networkList(client, json) {
   const networks = await client.listNetworks();
   const filtered = networks.filter((n) => !n.isPersonal);
+  if (json) {
+    console.log(JSON.stringify(filtered));
+    return;
+  }
   heading("Networks");
   networkTable(filtered);
   console.log();
 }
-async function networkCreate(client, name, prompt) {
+async function networkCreate(client, name, prompt, json) {
   if (!name) {
     error("Usage: index network create <name>", 1);
     return;
   }
   const network = await client.createNetwork(name, prompt);
+  if (json) {
+    console.log(JSON.stringify(network));
+    return;
+  }
   success(`Network created: ${network.title}`);
   if (network.key) {
     dim(`  Key: ${network.key}`);
@@ -1817,35 +1953,47 @@ async function networkCreate(client, name, prompt) {
   dim(`  ID: ${network.id}`);
   dim(`  Join Policy: ${(network.joinPolicy ?? "invite_only").replace("_", " ")}`);
 }
-async function networkShow(client, id) {
+async function networkShow(client, id, json) {
   if (!id) {
     error("Usage: index network show <id>", 1);
     return;
   }
   const network = await client.getNetwork(id);
-  networkCard(network);
   const members = await client.getNetworkMembers(id);
+  if (json) {
+    console.log(JSON.stringify({ ...network, members }));
+    return;
+  }
+  networkCard(network);
   heading("Members");
   memberTable(members);
   console.log();
 }
-async function networkJoin(client, id) {
+async function networkJoin(client, id, json) {
   if (!id) {
     error("Usage: index network join <id>", 1);
     return;
   }
   const network = await client.joinNetwork(id);
+  if (json) {
+    console.log(JSON.stringify(network));
+    return;
+  }
   success(`Joined network: ${network.title}`);
 }
-async function networkLeave(client, id) {
+async function networkLeave(client, id, json) {
   if (!id) {
     error("Usage: index network leave <id>", 1);
     return;
   }
   await client.leaveNetwork(id);
+  if (json) {
+    console.log(JSON.stringify({ id, left: true }));
+    return;
+  }
   success("Left network.");
 }
-async function networkUpdate(client, id, options) {
+async function networkUpdate(client, id, options, json) {
   if (!id) {
     error("Usage: index network update <id> [--title <t>] [--prompt <p>]", 1);
     return;
@@ -1860,25 +2008,33 @@ async function networkUpdate(client, id, options) {
     return;
   }
   const result = await client.callTool("update_index", { indexId: id, settings });
+  if (json) {
+    console.log(JSON.stringify(result));
+    return;
+  }
   if (!result.success) {
     error(result.error ?? "Network update failed", 1);
     return;
   }
   success("Network updated.");
 }
-async function networkDelete(client, id) {
+async function networkDelete(client, id, json) {
   if (!id) {
     error("Usage: index network delete <id>", 1);
     return;
   }
   const result = await client.callTool("delete_index", { indexId: id });
+  if (json) {
+    console.log(JSON.stringify(result));
+    return;
+  }
   if (!result.success) {
     error(result.error ?? "Network deletion failed", 1);
     return;
   }
   success("Network deleted.");
 }
-async function networkInvite(client, id, email) {
+async function networkInvite(client, id, email, json) {
   if (!id || !email) {
     error("Usage: index network invite <id> <email>", 1);
     return;
@@ -1890,6 +2046,10 @@ async function networkInvite(client, id, email) {
   }
   const user = users[0];
   const result = await client.addNetworkMember(id, user.id);
+  if (json) {
+    console.log(JSON.stringify({ user, ...result }));
+    return;
+  }
   success(`Invited ${user.name} (${user.email}) to the network.`);
   if (result.message) {
     dim(`  ${result.message}`);
@@ -2021,6 +2181,10 @@ Conversation Commands:
 `;
 async function handleConversation(client, subcommand, positionals, options) {
   if (!subcommand) {
+    if (options?.json) {
+      error("`--json` requires an explicit conversation subcommand.", 1);
+      return;
+    }
     if (options?.message) {
       await chatOneShot(client, options.message, options.sessionId);
     } else {
@@ -2030,19 +2194,19 @@ async function handleConversation(client, subcommand, positionals, options) {
   }
   switch (subcommand) {
     case "sessions":
-      await chatSessionsList(client);
+      await chatSessionsList(client, options?.json);
       return;
     case "list":
-      await conversationList(client);
+      await conversationList(client, options?.json);
       return;
     case "with":
-      await conversationWith(client, positionals[0]);
+      await conversationWith(client, positionals[0], options?.json);
       return;
     case "show":
-      await conversationShow(client, positionals[0], options?.limit);
+      await conversationShow(client, positionals[0], options?.limit, options?.json);
       return;
     case "send":
-      await conversationSend(client, positionals[0], positionals.slice(1));
+      await conversationSend(client, positionals[0], positionals.slice(1), options?.json);
       return;
     case "stream":
       await conversationStream(client);
@@ -2054,30 +2218,42 @@ async function handleConversation(client, subcommand, positionals, options) {
       error(`Unknown conversation subcommand: ${subcommand}`, 1);
   }
 }
-async function conversationList(client) {
+async function conversationList(client, json) {
   const conversations = await client.listConversations();
+  if (json) {
+    console.log(JSON.stringify(conversations));
+    return;
+  }
   heading("Conversations");
   conversationTable(conversations);
   console.log();
 }
-async function conversationWith(client, userId) {
+async function conversationWith(client, userId, json) {
   if (!userId) {
     error("Usage: index conversation with <user-id>", 1);
     return;
   }
   const conversation = await client.getOrCreateDM(userId);
+  if (json) {
+    console.log(JSON.stringify(conversation));
+    return;
+  }
   conversationCard(conversation);
 }
-async function conversationShow(client, id, limit) {
+async function conversationShow(client, id, limit, json) {
   if (!id) {
     error("Usage: index conversation show <id>", 1);
     return;
   }
   const messages = await client.getMessages(id, { limit: limit ?? 20 });
+  if (json) {
+    console.log(JSON.stringify(messages));
+    return;
+  }
   heading("Messages");
   messageList(messages);
 }
-async function conversationSend(client, id, messageParts) {
+async function conversationSend(client, id, messageParts, json) {
   if (!id) {
     error("Usage: index conversation send <id> <message>", 1);
     return;
@@ -2088,6 +2264,10 @@ async function conversationSend(client, id, messageParts) {
   }
   const text = messageParts.join(" ");
   const msg = await client.sendMessage(id, text);
+  if (json) {
+    console.log(JSON.stringify(msg));
+    return;
+  }
   success(`Message sent (${msg.id})`);
 }
 async function conversationStream(client) {
@@ -2141,8 +2321,12 @@ async function conversationStream(client) {
     reader.releaseLock();
   }
 }
-async function chatSessionsList(client) {
+async function chatSessionsList(client, json) {
   const sessions = await client.listSessions();
+  if (json) {
+    console.log(JSON.stringify(sessions));
+    return;
+  }
   heading("Chat Sessions");
   sessionTable(sessions);
   console.log();
@@ -2433,10 +2617,38 @@ async function handleSync(client, options) {
   success("Context synced to ~/.index/context.json");
 }
 
+// src/onboarding.command.ts
+var ONBOARDING_HELP = `
+Onboarding Commands:
+  index onboarding complete   Mark onboarding as complete
+`;
+async function handleOnboarding(client, subcommand, options) {
+  if (subcommand === "complete") {
+    await onboardingComplete(client, options?.json);
+    return;
+  }
+  console.log(ONBOARDING_HELP);
+}
+async function onboardingComplete(client, json) {
+  if (!json) {
+    info("Completing onboarding...");
+  }
+  const result = await client.callTool("complete_onboarding", {});
+  if (json) {
+    console.log(JSON.stringify(result));
+    return;
+  }
+  if (result.success) {
+    success("Onboarding marked as complete.");
+  } else {
+    error(result.error ?? "Failed to complete onboarding.");
+  }
+}
+
 // src/main.ts
 var DEFAULT_API_URL = "https://protocol.index.network";
 var DEFAULT_APP_URL = "https://index.network";
-var VERSION = "0.7.0";
+var VERSION = "0.9.2";
 var HELP_TEXT = `
 Index CLI v${VERSION}
 
@@ -2629,14 +2841,16 @@ async function main() {
     case "network":
       await handleNetwork(client, args.subcommand, args.positionals ?? [], {
         prompt: args.prompt,
-        title: args.title
+        title: args.title,
+        json: args.json
       });
       return;
     case "conversation":
       await handleConversation(client, args.subcommand, args.positionals ?? [], {
         limit: args.limit,
         sessionId: args.sessionId,
-        message: args.message
+        message: args.message,
+        json: args.json
       });
       return;
     case "contact":
@@ -2653,16 +2867,7 @@ async function main() {
       });
       return;
     case "onboarding":
-      if (args.subcommand === "complete") {
-        const result = await client.callTool("complete_onboarding", {});
-        if (!result.success) {
-          error(result.error ?? "Onboarding completion failed", 1);
-        } else {
-          success("Onboarding completed.");
-        }
-      } else {
-        error("Usage: index onboarding complete", 1);
-      }
+      await handleOnboarding(client, args.subcommand, { json: args.json });
       return;
     case "sync":
       await handleSync(client, { json: args.json });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indexnetwork/cli",
-  "version": "0.9.0",
+  "version": "0.9.2",
   "description": "Command-line interface for Index Network",
   "license": "MIT",
   "type": "module",
@@ -20,10 +20,10 @@
     "publish:all": "bun scripts/publish.ts"
   },
   "optionalDependencies": {
-    "@indexnetwork/cli-linux-x64": "0.9.0",
-    "@indexnetwork/cli-linux-arm64": "0.9.0",
-    "@indexnetwork/cli-darwin-x64": "0.9.0",
-    "@indexnetwork/cli-darwin-arm64": "0.9.0"
+    "@indexnetwork/cli-linux-x64": "0.9.2",
+    "@indexnetwork/cli-linux-arm64": "0.9.2",
+    "@indexnetwork/cli-darwin-x64": "0.9.2",
+    "@indexnetwork/cli-darwin-arm64": "0.9.2"
   },
   "devDependencies": {
     "@types/bun": "latest"