mindsim 0.1.1 → 0.1.3

package/src/auth.ts

@@ -1,131 +1,287 @@
-import http from "node:http";
-import url from "node:url";
+import readline from "node:readline";
+import axios from "axios";
 import open from "open";
-import { getAuthConfig, saveApiKey } from "./config";
-import type { AuthResponse } from "./types";
+import { getDeviceAuthConfig, saveApiKey } from "./config";
+import type {
+  DeviceAuthResponse,
+  SdkKeyDetailResponse,
+  SdkKeyInfo,
+  SdkKeysResponse,
+  TokenResponse,
+} from "./types";
 
-// CONFIGURATION
-const authConfig = getAuthConfig();
+const HTTP_TIMEOUT = 30000;
 
-/**
- * Starts the login flow
- */
 export async function login(): Promise<void> {
-  console.log("Initiating authentication...");
+  const authConfig = getDeviceAuthConfig();
 
-  // 1. Create a Promise that resolves when the local server receives the code
-  const apiKey = await listenForCallback();
+  console.log("Initiating authentication...\n");
 
-  console.log("Authorization succeeded.");
+  const deviceAuth = await requestDeviceCode(authConfig);
 
-  // 2. Exchange authorization code for access token
+  console.log("To authenticate, visit the following URL:");
+  console.log(`\n  ${deviceAuth.verification_uri_complete}\n`);
+  console.log(`Your code: ${deviceAuth.user_code}\n`);
+
+  await open(deviceAuth.verification_uri_complete);
+
+  console.log("Waiting for authentication...");
+
+  const tokenResponse = await pollForToken(
+    authConfig,
+    deviceAuth.device_code,
+    deviceAuth.interval,
+    deviceAuth.expires_in,
+  );
+
+  console.log("\nAuthentication successful!");
+
+  console.log("Fetching your API keys...\n");
+  const keysResponse = await fetchUserKeys(authConfig, tokenResponse.access_token);
+
+  if (keysResponse.keys.length === 0) {
+    throw new Error(
+      "No API keys found. Please visit https://app.workflows.com and go to the Developer Portal to create an app and API key.",
+    );
+  }
+
+  let selectedKeyId: string;
+  if (keysResponse.keys.length === 1) {
+    const onlyKey = keysResponse.keys[0] as SdkKeyInfo;
+    selectedKeyId = onlyKey.id;
+    console.log(`Auto-selecting your only key: ${onlyKey.name}`);
+  } else {
+    selectedKeyId = await selectKey(keysResponse.keys);
+  }
+
+  const keyDetail = await fetchKeySecret(authConfig, tokenResponse.access_token, selectedKeyId);
+
+  saveApiKey(keyDetail.key.key);
+
+  console.log("\n✅ Successfully logged in! Credentials saved.");
+}
+
+interface AuthConfig {
+  deviceAuthUrl: string;
+  tokenUrl: string;
+  clientId: string;
+  sdkKeysApiUrl: string;
+}
+
+async function requestDeviceCode(authConfig: AuthConfig): Promise<DeviceAuthResponse> {
   try {
-    // 3. Save credentials to disk
-    saveApiKey(apiKey);
+    const response = await axios.post<DeviceAuthResponse>(
+      authConfig.deviceAuthUrl,
+      new URLSearchParams({
+        client_id: authConfig.clientId,
+      }).toString(),
+      {
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded",
+        },
+        timeout: HTTP_TIMEOUT,
+      },
+    );
 
-    console.log("✅ Successfully logged in! Credentials saved.");
+    return response.data;
   } catch (error) {
-    console.error("❌ Authentication failed:", error);
-    process.exit(1);
+    if (axios.isAxiosError(error)) {
+      if (error.code === "ECONNABORTED") {
+        throw new Error("Device authorization request timed out. Please try again.");
+      }
+      if (error.response) {
+        const data = error.response.data as { error?: string; error_description?: string };
+        throw new Error(
+          `Device authorization failed: ${data.error_description || data.error || "Unknown error"}`,
+        );
+      }
+    }
+    throw error;
   }
 }
 
-/**
- * Spins up a temporary local server to catch the redirect
- */
-function listenForCallback(): Promise<string> {
-  const callbackPath = new URL(authConfig.authRedirectPath).pathname;
-
-  return new Promise((resolve, reject) => {
-    const server = http.createServer(async (req, res) => {
-      if (!req.url) return;
-
-      const parsedUrl = url.parse(req.url, true);
-
-      const headers = {
-        "Access-Control-Allow-Origin": new URL(authConfig.authServerUrl).origin,
-        "Access-Control-Allow-Methods": "OPTIONS, POST, GET",
-        "Access-Control-Max-Age": 2592000, // 30 days
-        "Access-Control-Allow-Headers": "Content-Type,Authorization",
-        "Access-Control-Allow-Credentials": "true",
-      };
-
-      // Check if the request is for the callback path
-      if (parsedUrl.pathname === callbackPath) {
-        if (req.method === "OPTIONS") {
-          res.writeHead(204, headers);
-          res.end();
-          return;
+async function pollForToken(
+  authConfig: AuthConfig,
+  deviceCode: string,
+  interval: number,
+  expiresIn: number,
+): Promise<TokenResponse> {
+  const startTime = Date.now();
+  const expiresAtMs = startTime + expiresIn * 1000;
+  let currentInterval = interval;
+
+  while (Date.now() < expiresAtMs) {
+    await sleep(currentInterval * 1000);
+
+    try {
+      const response = await axios.post<TokenResponse>(
+        authConfig.tokenUrl,
+        new URLSearchParams({
+          grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+          device_code: deviceCode,
+          client_id: authConfig.clientId,
+        }).toString(),
+        {
+          headers: {
+            "Content-Type": "application/x-www-form-urlencoded",
+          },
+          timeout: HTTP_TIMEOUT,
+        },
+      );
+
+      return response.data;
+    } catch (error) {
+      if (axios.isAxiosError(error) && error.response) {
+        const errorData = error.response.data as { error?: string };
+        const errorCode = errorData?.error;
+
+        if (errorCode === "authorization_pending") {
+          continue;
         }
 
-        if (req.method === "POST") {
-          let body = "";
-
-          req.on("data", (chunk) => {
-            body += chunk.toString(); // Collect data chunks
-          });
-
-          req.on("end", () => {
-            let authResponseData: AuthResponse | null = null;
-
-            try {
-              authResponseData = JSON.parse(body);
-            } catch (err) {
-              console.error(`Got an invalid response: ${body}. Reason: ${err}`);
-              reject(err);
-            }
-
-            if (!authResponseData) {
-              res.end("No api key found");
-              return;
-            }
-
-            const apiKey = authResponseData?.apiKey?.key;
-
-            if (!apiKey) {
-              res.writeHead(400, { "Content-Type": "text/html" });
-              res.end(`<h1>Authentication Error</h1><p>API Key Not Found</p>`);
-              server.close();
-              reject(new Error("API Key Not Found"));
-              return;
-            }
-
-            if (apiKey) {
-              // Send a nice "Close this window" message to the user
-              res.writeHead(200, { "Content-Type": "text/html", ...headers });
-              res.end(`
-                <h1>Authentication Successful</h1>
-                <p>You can close this window and return to your terminal.</p>
-                <script>window.close()</script>
-              `);
-
-              server.close();
-              resolve(apiKey);
-            } else {
-              res.end("No code found");
-            }
-          });
+        if (errorCode === "slow_down") {
+          currentInterval += 1;
+          continue;
         }
-      }
-    });
 
-    server.listen(authConfig.listenPort, async () => {
-      const state = JSON.stringify({
-        redirect: `${authConfig.authServerLandingPath}?initCallbackUrl=${encodeURIComponent(authConfig.authRedirectPath)}`,
-      });
+        if (errorCode === "expired_token") {
+          throw new Error("Authentication timed out. Please try again.");
+        }
 
-      const encodedState = btoa(state);
+        if (errorCode === "access_denied") {
+          throw new Error("Authentication was denied. Please try again.");
+        }
+      }
 
-      const loginUrl = `${authConfig.authServerUrl}?state=${encodedState}`;
+      throw error;
+    }
+  }
 
-      console.log(`Listening on port ${authConfig.listenPort}...`);
-      console.log(`Opening browser to: ${loginUrl}`);
+  throw new Error("Authentication timed out. Please try again.");
+}
 
-      await open(loginUrl);
+async function fetchUserKeys(
+  authConfig: AuthConfig,
+  accessToken: string,
+): Promise<SdkKeysResponse> {
+  try {
+    const response = await axios.get<SdkKeysResponse>(authConfig.sdkKeysApiUrl, {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+      },
+      timeout: HTTP_TIMEOUT,
     });
 
-    server.on("error", (err) => {
-      reject(err);
+    return response.data;
+  } catch (error) {
+    if (axios.isAxiosError(error)) {
+      if (error.code === "ECONNABORTED") {
+        throw new Error("Request to fetch API keys timed out. Please try again.");
+      }
+      if (error.response) {
+        const status = error.response.status;
+        const data = error.response.data as { error?: string; code?: string };
+
+        if (status === 401) {
+          throw new Error(`Authentication failed: ${data.error || "Invalid or expired token"}`);
+        }
+        if (status === 404) {
+          throw new Error(
+            `User not found: ${data.error || "Your account may not be set up correctly"}`,
+          );
+        }
+
+        throw new Error(`Failed to fetch API keys: ${data.error || "Unknown error"}`);
+      }
+    }
+    throw error;
+  }
+}
+
+async function fetchKeySecret(
+  authConfig: AuthConfig,
+  accessToken: string,
+  keyId: string,
+): Promise<SdkKeyDetailResponse> {
+  try {
+    const response = await axios.get<SdkKeyDetailResponse>(`${authConfig.sdkKeysApiUrl}/${keyId}`, {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+      },
+      timeout: HTTP_TIMEOUT,
     });
+
+    return response.data;
+  } catch (error) {
+    if (axios.isAxiosError(error)) {
+      if (error.code === "ECONNABORTED") {
+        throw new Error("Request to fetch API key details timed out. Please try again.");
+      }
+      if (error.response) {
+        const status = error.response.status;
+        const data = error.response.data as { error?: string; code?: string };
+
+        if (status === 401) {
+          throw new Error(`Authentication failed: ${data.error || "Invalid or expired token"}`);
+        }
+        if (status === 403) {
+          throw new Error(`Access denied: ${data.error || "You do not have access to this key"}`);
+        }
+        if (status === 404) {
+          throw new Error(
+            `Key not found: ${data.error || "The selected key may have been deleted"}`,
+          );
+        }
+
+        throw new Error(`Failed to fetch API key details: ${data.error || "Unknown error"}`);
+      }
+    }
+    throw error;
+  }
+}
+
+async function selectKey(keys: SdkKeyInfo[]): Promise<string> {
+  if (!process.stdin.isTTY) {
+    throw new Error(
+      "Multiple API keys found but running in non-interactive mode. Please set MINDSIM_API_KEY environment variable directly.",
+    );
+  }
+
+  console.log("Select an API key:\n");
+
+  for (const [index, key] of keys.entries()) {
+    const appName = key.app?.name || "No app";
+    console.log(`  ${index + 1}. ${key.name}`);
+    console.log(`     Tier: ${key.tier} | App: ${appName}`);
+    console.log();
+  }
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
   });
+
+  return new Promise((resolve) => {
+    const askQuestion = () => {
+      rl.question(`Enter selection (1-${keys.length}): `, (answer) => {
+        const selection = Number.parseInt(answer, 10);
+
+        if (Number.isNaN(selection) || selection < 1 || selection > keys.length) {
+          console.log(`Please enter a number between 1 and ${keys.length}`);
+          askQuestion();
+          return;
+        }
+
+        const selectedKey = keys[selection - 1] as SdkKeyInfo;
+        rl.close();
+        resolve(selectedKey.id);
+      });
+    };
+
+    askQuestion();
+  });
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }

package/src/cli.ts

@@ -2,7 +2,7 @@
 
 import fs from "node:fs";
 import path from "node:path";
-import { Command, Option } from "commander";
+import { Command } from "commander";
 import { login } from "./auth";
 import { MindSim } from "./index";
 import { checkForUpdates, getPackageVersion, updateSdk } from "./version";
@@ -15,7 +15,7 @@ const program = new Command();
 const getSDK = () => {
   try {
     return new MindSim();
-  } catch (error) {
+  } catch {
     console.error("❌ Authentication required.");
     console.error("Please run 'mindsim auth' or set MINDSIM_API_KEY environment variable.");
     process.exit(1);
@@ -213,6 +213,26 @@ const main = async () => {
       }
     });
 
+  snapshots
+    .command("get")
+    .description("Get snapshot detail")
+    .argument("<mindId>", "ID of the mind")
+    .argument("<snapshotId>", "ID of the snapshot")
+    .option("--transcript", "Include transcript")
+    .option("--psychometrics", "Include psychometrics")
+    .action(async (mindId, snapshotId, options) => {
+      try {
+        const client = getSDK();
+        const result = await client.snapshots.getDetail(mindId, snapshotId, {
+          includeTranscript: options.transcript,
+          includePsychometrics: options.psychometrics,
+        });
+        printOutput(result);
+      } catch (err) {
+        handleError(err);
+      }
+    });
+
   snapshots
     .command("create")
     .description("Upload a file to create a snapshot")
@@ -260,6 +280,51 @@ const main = async () => {
       }
     });
 
+  snapshots
+    .command("delete")
+    .description("Delete a snapshot")
+    .argument("<mindId>", "ID of the mind")
+    .argument("<snapshotId>", "ID of the snapshot")
+    .action(async (mindId, snapshotId) => {
+      try {
+        const client = getSDK();
+        const result = await client.snapshots.delete(mindId, snapshotId);
+        printOutput(result);
+      } catch (err) {
+        handleError(err);
+      }
+    });
+
+  snapshots
+    .command("link")
+    .description("Link snapshot to digital twin")
+    .argument("<mindId>", "ID of the mind")
+    .argument("<snapshotId>", "ID of the snapshot")
+    .action(async (mindId, snapshotId) => {
+      try {
+        const client = getSDK();
+        const result = await client.snapshots.link(mindId, snapshotId);
+        printOutput(result);
+      } catch (err) {
+        handleError(err);
+      }
+    });
+
+  snapshots
+    .command("unlink")
+    .description("Unlink snapshot from digital twin")
+    .argument("<mindId>", "ID of the mind")
+    .argument("<snapshotId>", "ID of the snapshot")
+    .action(async (mindId, snapshotId) => {
+      try {
+        const client = getSDK();
+        const result = await client.snapshots.unlink(mindId, snapshotId);
+        printOutput(result);
+      } catch (err) {
+        handleError(err);
+      }
+    });
+
   // ==========================================
   // SIMULATIONS RESOURCES
   // ==========================================
@@ -399,6 +464,32 @@ const main = async () => {
       }
     });
 
+  psychometrics
+    .command("topics")
+    .description("Get topic analysis")
+    .argument("<snapshotId>")
+    .action(async (sid) => {
+      try {
+        const client = getSDK();
+        printOutput(await client.mindTopics.get(sid));
+      } catch (e) {
+        handleError(e);
+      }
+    });
+
+  // USERS
+  program
+    .command("users")
+    .description("List organization users")
+    .action(async () => {
+      try {
+        const client = getSDK();
+        printOutput(await client.users.list());
+      } catch (e) {
+        handleError(e);
+      }
+    });
+
   program.parse(process.argv);
 };
 

package/src/config.ts

@@ -1,13 +1,13 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import type { AuthConfig } from "./types";
+import type { DeviceAuthConfig } from "./types";
 
-const API_BASE_URL = "https://app.mindsim.com/api/public/v1";
-const AUTH_SERVER_URL = "https://app.mindsim.com/sdk/authorize";
-const AUTH_SERVER_LANDING_PATH = "/sdk-success";
-const AUTH_REDIRECT_URI = "http://localhost:4242/callback";
-const AUTH_PORT = "4242";
+const API_BASE_URL = "https://api.reasoner.com/api/mindsim";
+const WORKOS_DEVICE_AUTH_URL = "https://auth.reasoner.com/user_management/authorize/device";
+const WORKOS_TOKEN_URL = "https://auth.reasoner.com/user_management/authenticate";
+const WORKOS_CLIENT_ID = "client_01GPECHM1J9DMY7WQNKTJ195P6";
+const SDK_KEYS_API_URL = "https://api.reasoner.com/api/sdk/keys";
 
 export function getConfigDir() {
   return path.join(os.homedir(), ".mindsim");
@@ -46,12 +46,12 @@ export const saveApiKey = (apiKey: string): void => {
   fs.writeFileSync(configFile, JSON.stringify({ apiKey }, null, 2));
 };
 
-export const getAuthConfig = (): AuthConfig => {
+export const getDeviceAuthConfig = (): DeviceAuthConfig => {
   return {
-    authServerUrl: process.env.MINDSIM_AUTH_SERVER_URL || AUTH_SERVER_URL,
-    authServerLandingPath: AUTH_SERVER_LANDING_PATH,
-    authRedirectPath: process.env.MINDSIM_AUTH_REDIRECT_URI || AUTH_REDIRECT_URI,
-    listenPort: process.env.MINDSIM_AUTH_PORT || AUTH_PORT,
+    deviceAuthUrl: process.env.MINDSIM_WORKOS_DEVICE_AUTH_URL || WORKOS_DEVICE_AUTH_URL,
+    tokenUrl: process.env.MINDSIM_WORKOS_TOKEN_URL || WORKOS_TOKEN_URL,
+    clientId: process.env.MINDSIM_WORKOS_CLIENT_ID || WORKOS_CLIENT_ID,
+    sdkKeysApiUrl: process.env.MINDSIM_SDK_KEYS_API_URL || SDK_KEYS_API_URL,
   };
 };
 

package/src/index.ts

@@ -1,11 +1,13 @@
 import axios, { type AxiosInstance } from "axios";
 import { getApiBaseUrl, loadApiKey } from "./config";
 import { ArtifactsResource } from "./resources/artifacts";
+import { MindTopicsResource } from "./resources/mind-topics";
 import { MindsResource } from "./resources/minds";
 import { PsychometricsResource } from "./resources/psychometrics";
 import { SimulationsResource } from "./resources/simulations";
 import { SnapshotsResource } from "./resources/snapshots";
 import { TagsResource } from "./resources/tags";
+import { UsersResource } from "./resources/users";
 import { checkForUpdates, getPackageVersion } from "./version";
 
 export class MindSim {
@@ -13,10 +15,12 @@ export class MindSim {
 
   public artifacts: ArtifactsResource;
   public minds: MindsResource;
+  public mindTopics: MindTopicsResource;
   public psychometrics: PsychometricsResource;
   public snapshots: SnapshotsResource;
   public simulations: SimulationsResource;
   public tags: TagsResource;
+  public users: UsersResource;
 
   constructor(apiKey?: string, options?: { apiBaseUrl?: string }) {
     // 1. Trigger the auto-update check (Fire and forget, do not await)
@@ -48,10 +52,12 @@ export class MindSim {
 
     this.artifacts = new ArtifactsResource(this.client);
     this.minds = new MindsResource(this.client);
+    this.mindTopics = new MindTopicsResource(this.client);
     this.psychometrics = new PsychometricsResource(this.client);
     this.snapshots = new SnapshotsResource(this.client);
     this.simulations = new SimulationsResource(this.client);
     this.tags = new TagsResource(this.client);
+    this.users = new UsersResource(this.client);
   }
 }
 

package/src/resources/mind-topics.ts

@@ -0,0 +1,16 @@
+import type { AxiosInstance } from "axios";
+import type { GetMindTopicsResponse } from "../types";
+
+export class MindTopicsResource {
+  constructor(private client: AxiosInstance) {}
+
+  /**
+   * Get topic analysis for a specific snapshot
+   */
+  async get(snapshotId: string): Promise<GetMindTopicsResponse> {
+    const response = await this.client.get<GetMindTopicsResponse>(
+      `/snapshots/${snapshotId}/mind-topics`,
+    );
+    return response.data;
+  }
+}