intella-cli 0.0.4 → 0.0.6

package/bin/intella.js

@@ -251782,7 +251782,7 @@ class ClaudeAgent extends BaseAgent {
         const customProvider = createClaudeCode({
           defaultSettings: settings
         });
-        this.modelInstance = customProvider(modelId);
+        this.modelInstance = customProvider(modelId, settings);
       } else {
         this.modelInstance = claudeCode(modelId);
       }
@@ -251810,10 +251810,19 @@ class CodexAgent extends BaseAgent {
         this.modelInstance = codexCli2(modelId, {
           reasoningEffort: this.config.reasoningEffort,
           approvalMode: this.config.approvalMode,
-          sandboxMode: this.config.sandboxMode,
+          sandboxMode: this.config.sandboxMode || "workspace-write",
           mcpServers: this.config.mcpServers,
           verbose: this.config.verbose,
-          logger: this.config.logger
+          logger: this.config.logger,
+          dangerouslyBypassApprovalsAndSandbox: this.config.dangerouslyBypassApprovalsAndSandbox,
+          allowNpx: this.config.allowNpx,
+          cwd: this.config.cwd,
+          fullAuto: this.config.fullAuto || true,
+          webSearch: this.config.webSearch || true,
+          configOverrides: {
+            sandbox_workspace_write: { network_access: true },
+            ...this.config.configOverrides || {}
+          }
         });
       } else {
         this.modelInstance = codexCli2(modelId);
@@ -253784,7 +253793,13 @@ class OpenCodeAgent extends BaseAgent {
   async getModel() {
     if (!this.modelInstance) {
       const modelId = this.config.model || "anthropic/claude-sonnet-4-5-20250929";
-      this.modelInstance = opencode(modelId);
+      console.log("modelId", modelId);
+      console.log("cwd", this.config.cwd);
+      this.modelInstance = opencode(modelId, {
+        cwd: this.config.cwd,
+        verbose: this.config.verbose,
+        tools: this.config.tools
+      });
     }
     return this.modelInstance;
   }
@@ -306235,8 +306250,8 @@ var import_ulid_uuid_converter = __toESM(require_dist8(), 1);
 
 class IdGenerator {
   static ulid = monotonicFactory();
-  static generateIds() {
-    const ulid4 = this.ulid();
+  static generateIds(timestamp) {
+    const ulid4 = this.ulid(timestamp);
     const uuid5 = this.ulidToUuid(ulid4);
     return [ulid4, uuid5];
   }
@@ -306363,6 +306378,7 @@ async function publishChunkToSession(sessionId, chunk, redisUrl) {
       chunkId,
       chunk: chunk.chunk || "",
       segmentId: chunk.segmentId || "",
+      parentSegmentId: chunk.parentSegmentId || "",
       isDone: chunk.isDone ? "true" : "false",
       type: chunk.type || "text-delta",
       senderType: chunk.senderType || "",
@@ -306680,15 +306696,13 @@ import { existsSync as existsSync8, readFileSync as readFileSync8, writeFileSync
 init_config();
 async function getUserInfo() {
   try {
-    const token = await getAccessToken();
-    if (!token) {
+    const authHeaders = await getAuthHeaders();
+    if (!authHeaders || Object.keys(authHeaders).length === 0) {
       return null;
     }
     const config4 = getConfig();
     const response = await fetch(`${config4.apiUrl}/api/v1/auth/me`, {
-      headers: {
-        Authorization: `Bearer ${token}`
-      }
+      headers: authHeaders
     });
     if (response.ok) {
       return await response.json();
@@ -306721,6 +306735,25 @@ async function refreshToken(refreshToken2) {
     return null;
   }
 }
+async function getOrCreateApiKey(accessToken) {
+  try {
+    const config4 = getConfig();
+    const apiKeyUrl = `${config4.apiUrl}/api/v1/auth/api-key`;
+    const response = await fetch(apiKeyUrl, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${accessToken}`
+      }
+    });
+    if (!response.ok) {
+      return null;
+    }
+    const data = await response.json();
+    return data.api_key || null;
+  } catch (error49) {
+    return null;
+  }
+}
 
 // auth.ts
 function getAuth() {
@@ -306755,7 +306788,7 @@ function clearAuth() {
     }
   }
 }
-async function getAccessToken() {
+async function getAccessToken2() {
   const auth = getAuth();
   if (!auth) {
     return null;
@@ -306790,13 +306823,68 @@ async function getAccessToken() {
   }
   return null;
 }
+async function getAuthHeaders() {
+  const auth = getAuth();
+  if (!auth) {
+    return {};
+  }
+  if (auth.type === "apikey") {
+    const envApiKey = process.env.INTELLA_API_KEY;
+    const apiKey = envApiKey || auth.apikey;
+    if (apiKey) {
+      return {
+        "X-API-Key": apiKey
+      };
+    }
+    if (auth.oauth?.refresh_token) {
+      const newApiKey = await refreshApiKeyFromRefreshToken(auth.oauth.refresh_token);
+      if (newApiKey) {
+        saveAuth({
+          type: "apikey",
+          apikey: newApiKey,
+          oauth: auth.oauth
+        });
+        return {
+          "X-API-Key": newApiKey
+        };
+      }
+    }
+    return {};
+  }
+  if (auth.type === "oauth" && auth.oauth) {
+    const token = await getAccessToken2();
+    if (token) {
+      return {
+        Authorization: `Bearer ${token}`
+      };
+    }
+  }
+  return {};
+}
+async function refreshApiKeyFromRefreshToken(refreshTokenValue) {
+  try {
+    const tokenData = await refreshToken(refreshTokenValue);
+    if (!tokenData || !tokenData.access_token) {
+      return null;
+    }
+    const apiKey = await getOrCreateApiKey(tokenData.access_token);
+    return apiKey;
+  } catch (error49) {
+    return null;
+  }
+}
 function setAuthType(type) {
   const auth = getAuth() || { type };
   if (type === "apikey") {
     const envApiKey = process.env.INTELLA_API_KEY;
     saveAuth({
       type: "apikey",
-      apikey: envApiKey || auth.apikey
+      apikey: envApiKey || auth.apikey,
+      oauth: auth.oauth ? {
+        refresh_token: auth.oauth.refresh_token,
+        access_token: "",
+        expires_at: 0
+      } : undefined
     });
   } else {
     saveAuth({
@@ -306825,13 +306913,11 @@ async function publishSessionEvent(sessionId, event) {
   const config4 = getConfig();
   const apiUrl = config4.apiUrl || "https://app.intella.xyz";
   const endpoint = `${apiUrl}/api/v1/sessions/${sessionId}/events`;
-  const token = await getAccessToken();
+  const authHeaders = await getAuthHeaders();
   const headers = {
-    "Content-Type": "application/json"
+    "Content-Type": "application/json",
+    ...authHeaders
   };
-  if (token) {
-    headers["Authorization"] = `Bearer ${token}`;
-  }
   try {
     const response = await fetch(endpoint, {
       method: "POST",
@@ -307044,7 +307130,11 @@ async function processAgentCommand(options, logger, doneCallback) {
     if (!agentConfig.executablePath) {
       agentConfig.executablePath = findClaudeBinary() || "/usr/local/bin/claude";
     }
-    agentConfig.allowedTools = ["Read", "Write", "Edit", "Bash", "WebSearch", "Grep"];
+    agentConfig.allowedTools = ["Read", "Write", "Edit", "Bash", "WebSearch", "Grep", "WebFetch"];
+  }
+  if (agentType === "codex") {
+    agentConfig.sandboxMode = "workspace-write";
+    agentConfig.dangerouslyBypassApprovalsAndSandbox = true;
   }
   agentConfig.model = model;
   log.info(`[DAEMON] Executing agent task with agent: ${agentType}`);
@@ -307060,30 +307150,89 @@ async function processAgentCommand(options, logger, doneCallback) {
   let fullResponse = "";
   const responseChunks = [];
   let chunkCount = 0;
-  let segmentId = IdGenerator.generatePrefixUlid("seg");
-  let segmentSent = false;
+  let mainSegmentId = IdGenerator.generatePrefixUlid("seg");
+  let firstTextChunkSent = false;
+  const isToolRelatedChunk = (type) => {
+    return type.startsWith("tool-") || type === "tool-call" || type === "tool-result" || type === "tool-error" || type === "tool-input-start" || type === "tool-input-end" || type === "tool-input-delta" || type === "tool-output-denied";
+  };
+  const shouldEmitEvent = (chunk) => {
+    if (chunk.isDone || chunk.type === "done" || chunk.type === "error" || chunk.type === "start") {
+      return true;
+    }
+    return false;
+  };
+  const config4 = getConfig();
+  let uniquePartId = {};
+  let textSegment = [];
   for await (const chunk of sdk.streamTask(taskRequest, agentType)) {
     chunkCount++;
     responseChunks.push({ ...chunk, timestamp: Date.now() });
+    const chunkData = chunk.data;
+    if (chunkData && chunkData.id || chunkData?.toolCallId) {
+      if (chunk.type === "text-start") {
+        if (!uniquePartId[chunkData.id]) {
+          if (textSegment.length > 0) {
+            uniquePartId[chunkData.id] = IdGenerator.generatePrefixUlid("seg");
+            textSegment.push(chunkData.id);
+          } else {
+            uniquePartId[chunkData.id] = mainSegmentId;
+            textSegment.push(chunkData.id);
+          }
+        }
+      } else if (chunk.type === "reasoning-start") {
+        if (!uniquePartId[chunkData.id]) {
+          uniquePartId[chunkData.id] = IdGenerator.generatePrefixUlid("seg");
+        }
+      } else if (chunk.type === "tool-input-start") {
+        if (!uniquePartId[chunkData.id]) {
+          uniquePartId[chunkData.id] = IdGenerator.generatePrefixUlid("seg");
+        }
+      }
+    }
     if (session?.id) {
-      const config4 = getConfig();
+      let currentSegmentId;
+      if (chunk.type === "text-delta" || chunk.type === "text-start" || chunk.type === "text-end") {
+        currentSegmentId = uniquePartId[chunkData.id];
+      } else if (isToolRelatedChunk(chunk.type)) {
+        if (chunkData.toolCallId) {
+          currentSegmentId = uniquePartId[chunkData.toolCallId];
+        } else if (chunkData.id) {
+          currentSegmentId = uniquePartId[chunkData.id];
+        } else {
+          currentSegmentId = IdGenerator.generatePrefixUlid("seg");
+        }
+      } else if (chunk.type.startsWith("reasoning")) {
+        if (chunkData.id) {
+          currentSegmentId = uniquePartId[chunkData.id];
+        } else {
+          currentSegmentId = mainSegmentId;
+        }
+      } else if (chunk.type === "file") {
+        currentSegmentId = IdGenerator.generatePrefixUlid("seg");
+      } else {
+        currentSegmentId = mainSegmentId;
+      }
       await publishChunkToSession(session.id, {
         chunk: chunk.text,
         isDone: chunk.isDone,
         type: chunk.type,
         senderType: "assistant",
         timestamp: Date.now(),
-        segmentId,
+        segmentId: currentSegmentId,
+        parentSegmentId: mainSegmentId,
         data: {
           agentType,
           ...chunk.data
         }
       }, config4.redisUrl);
-      agentResponseEmitter.emit("agent:response", {
-        chunk,
-        sessionId: session.id,
-        segmentId
-      });
+      if (shouldEmitEvent(chunk)) {
+        agentResponseEmitter.emit("agent:response", {
+          chunk,
+          sessionId: session.id,
+          segmentId: currentSegmentId,
+          parentSegmentId: mainSegmentId
+        });
+      }
       if (options.streamAgentResult) {
         await publishChunk(options.sandboxId, {
           chunk: chunk.text,
@@ -307091,17 +307240,14 @@ async function processAgentCommand(options, logger, doneCallback) {
           type: chunk.type,
           senderType: "assistant",
           timestamp: Date.now(),
-          segmentId,
+          segmentId: currentSegmentId,
+          parentSegmentId: mainSegmentId,
           data: {
             agentType,
             ...chunk.data
           }
         });
       }
-      if (!segmentSent) {
-      }
-    } else if (chunk.type === "text-delta") {
-      process.stdout.write(chunk.text);
     }
     if (chunk.isDone) {
       log.info(`[DAEMON] \u2705 Agent execution completed (${chunkCount} chunks, ${fullResponse.length} chars)`);
@@ -307141,8 +307287,35 @@ async function processAgentCommand(options, logger, doneCallback) {
 }
 var agentResponseEmitter = new EventEmitter;
 agentResponseEmitter.on("agent:response", async (response) => {
-  console.log("Agent response:", response);
-  await publishSessionEvent(response.sessionId, response.chunk);
+  let eventType = "chunk";
+  if (response.chunk.isDone || response.chunk.type === "done") {
+    eventType = "done";
+  } else if (response.chunk.type === "error") {
+    eventType = "error";
+  } else if (response.chunk.type.startsWith("tool")) {
+    eventType = "tool-use";
+  } else if (response.chunk.type.startsWith("start")) {
+    eventType = "start";
+  } else if (response.chunk.type.startsWith("status")) {
+    eventType = "status";
+  } else if (response.chunk.type.startsWith("thinking")) {
+    eventType = "thinking";
+  } else if (response.chunk.type.startsWith("attachments") || response.chunk.type.startsWith("file")) {
+    eventType = "attachments";
+  } else if (response.chunk.type.startsWith("finish")) {
+    eventType = "finish-step";
+  }
+  await publishSessionEvent(response.sessionId, {
+    type: eventType,
+    segmentId: response.segmentId,
+    parentSegmentId: response.parentSegmentId,
+    message: response.chunk.text || eventType,
+    data: {
+      ...response.chunk,
+      segmentId: response.segmentId,
+      parentSegmentId: response.parentSegmentId
+    }
+  });
 });
 
 // commands/sandbox.ts
@@ -307934,7 +308107,7 @@ async function loginCommand(options) {
           reject(new Error("Authentication timeout. Please try again."));
         }
       }, timeout);
-      listenToSSE(sseUrl, (data) => {
+      listenToSSE(sseUrl, async (data) => {
         if (resolved)
           return;
         if (data.type === "auth_success") {
@@ -307950,7 +308123,26 @@ async function loginCommand(options) {
             }
           });
           console.log("\u2705 Authentication successful!");
-          console.log(`   Access token stored securely in ${config4.authPath}\n`);
+          console.log("   Fetching API key for persistent authentication...");
+          const apiKey = await getOrCreateApiKey(data.access_token);
+          if (apiKey) {
+            saveAuth({
+              type: "apikey",
+              apikey: apiKey,
+              oauth: {
+                refresh_token: data.refresh_token || "",
+                access_token: "",
+                expires_at: 0
+              }
+            });
+            console.log("\u2705 API key stored successfully!");
+            console.log(`   You can now authenticate without worrying about token expiration.`);
+            console.log(`   Refresh token saved as fallback in case API key is deleted.`);
+            console.log(`   Credentials stored securely in ${config4.authPath}\n`);
+          } else {
+            console.log("\u26A0\uFE0F  Warning: Could not fetch API key, using OAuth tokens (may expire)");
+            console.log(`   Access token stored securely in ${config4.authPath}\n`);
+          }
           resolve8();
         } else if (data.type === "auth_error") {
           clearTimeout(timeoutId);
@@ -309166,4 +309358,4 @@ yargs_default(hideBin(process.argv)).scriptName("intella-cli").version("1.0.0").
   await whoamiCommand();
 }).demandCommand(1, "You need at least one command before moving on").help().alias("help", "h").alias("version", "v").strict().parse();
 
-//# debugId=035B99541C02033564756E2164756E21
+//# debugId=83DEEA96E1B6BF6164756E2164756E21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "intella-cli",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "bin": {
     "intella": "bin/intella.js"
   },