@joshski/dust 0.1.63 → 0.1.64

package/dist/dust.js

@@ -3,14 +3,14 @@ import { createRequire } from "node:module";
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // lib/cli/run.ts
-import { existsSync, statSync as statSync2 } from "node:fs";
+import { existsSync, statSync as statSync3 } from "node:fs";
 import {
-  chmod as chmod2,
-  mkdir as mkdir2,
-  readdir as readdir2,
-  readFile as readFile2,
+  chmod as chmod3,
+  mkdir as mkdir3,
+  readdir as readdir3,
+  readFile as readFile3,
   rename,
-  writeFile as writeFile2
+  writeFile as writeFile3
 } from "node:fs/promises";
 
 // lib/git/file-sorter.ts
@@ -275,7 +275,7 @@ async function loadSettings(cwd, fileSystem) {
 }
 
 // lib/version.ts
-var DUST_VERSION = "0.1.63";
+var DUST_VERSION = "0.1.64";
 
 // lib/cli/dedent.ts
 function dedent(strings, ...values) {
@@ -1034,10 +1034,9 @@ async function audit(dependencies) {
 }
 
 // lib/cli/commands/bucket.ts
-import { spawn as nodeSpawn3 } from "node:child_process";
+import { spawn as nodeSpawn4 } from "node:child_process";
 import { accessSync, statSync } from "node:fs";
 import { chmod, mkdir, readdir, readFile, writeFile } from "node:fs/promises";
-import { createServer as httpCreateServer } from "node:http";
 import { homedir } from "node:os";
 
 // lib/bucket/auth.ts
@@ -1156,6 +1155,40 @@ async function authenticate(authDeps) {
   });
 }
 
+// lib/bucket/auth-server.ts
+import { spawn as nodeSpawn } from "node:child_process";
+import { createServer as httpCreateServer } from "node:http";
+function createLocalServer(handler) {
+  let resolvedPort = 0;
+  const server = httpCreateServer(async (nodeRequest, nodeResponse) => {
+    const url = new URL(nodeRequest.url ?? "/", `http://localhost:${resolvedPort}`);
+    const request = new Request(url.toString(), {
+      method: nodeRequest.method ?? "GET"
+    });
+    const response = handler(request);
+    const body = await response.text();
+    nodeResponse.writeHead(response.status, {
+      "Content-Type": response.headers.get("content-type") ?? "text/plain"
+    });
+    nodeResponse.end(body);
+  });
+  server.listen(0, () => {
+    const addr2 = server.address();
+    if (addr2 && typeof addr2 === "object") {
+      resolvedPort = addr2.port;
+    }
+  });
+  const addr = server.address();
+  if (addr && typeof addr === "object") {
+    resolvedPort = addr.port;
+  }
+  return { port: resolvedPort, stop: () => server.close() };
+}
+function openBrowser(url) {
+  const cmd = process.platform === "darwin" ? "open" : "xdg-open";
+  nodeSpawn(cmd, [url], { stdio: "ignore", detached: true }).unref();
+}
+
 // lib/bucket/events.ts
 var WS_OPEN = 1;
 function formatBucketEvent(event) {
@@ -1216,10 +1249,10 @@ function getReposDir(env, homeDir) {
 import { dirname as dirname2 } from "node:path";
 
 // lib/claude/spawn-claude-code.ts
-import { spawn as nodeSpawn } from "node:child_process";
+import { spawn as nodeSpawn2 } from "node:child_process";
 import { createInterface as nodeCreateInterface } from "node:readline";
 var defaultDependencies = {
-  spawn: nodeSpawn,
+  spawn: nodeSpawn2,
   createInterface: nodeCreateInterface
 };
 async function* spawnClaudeCode(prompt, options = {}, dependencies = defaultDependencies) {
@@ -1827,7 +1860,7 @@ function formatAgentEvent(event) {
 }
 
 // lib/cli/commands/loop.ts
-import { spawn as nodeSpawn2 } from "node:child_process";
+import { spawn as nodeSpawn3 } from "node:child_process";
 import os from "node:os";
 
 // lib/artifacts/workflow-tasks.ts
@@ -2011,19 +2044,21 @@ function formatLoopEvent(event) {
       return `\uD83C\uDFC1 Reached max iterations (${event.maxIterations}). Exiting.`;
   }
 }
-async function defaultPostEvent(url, payload) {
-  await fetch(url, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify(payload)
-  });
+function createPostEvent(fetchFn) {
+  return async (url, payload) => {
+    await fetchFn(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload)
+    });
+  };
 }
 function createDefaultDependencies() {
   return {
-    spawn: nodeSpawn2,
+    spawn: nodeSpawn3,
     run,
     sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
-    postEvent: defaultPostEvent
+    postEvent: createPostEvent(fetch)
   };
 }
 function createWireEventSender(eventsUrl, sessionId, postEvent, onError, getAgentSessionId, repository = "") {
@@ -2091,7 +2126,20 @@ async function runOneIteration(dependencies, loopDependencies, onLoopEvent, onAg
   const { context } = dependencies;
   const { spawn, run: run2 } = loopDependencies;
   const agentName = loopDependencies.agentType === "codex" ? "Codex" : "Claude";
-  const { onRawEvent, hooksInstalled = false, signal, logger = log } = options;
+  const {
+    onRawEvent,
+    hooksInstalled = false,
+    signal,
+    logger = log,
+    repositoryId
+  } = options;
+  const baseEnv = {
+    DUST_UNATTENDED: "1",
+    DUST_SKIP_AGENT: "1"
+  };
+  if (repositoryId) {
+    baseEnv.DUST_REPOSITORY_ID = repositoryId;
+  }
   log("syncing with remote");
   onLoopEvent({ type: "loop.syncing" });
   const pullResult = await gitPull(context.cwd, spawn);
@@ -2126,7 +2174,7 @@ Make sure the repository is in a clean state and synced with remote before finis
         spawnOptions: {
           cwd: context.cwd,
           dangerouslySkipPermissions: true,
-          env: { DUST_UNATTENDED: "1", DUST_SKIP_AGENT: "1" },
+          env: baseEnv,
           signal
         },
         onRawEvent
@@ -2182,7 +2230,7 @@ ${instructions}`;
       spawnOptions: {
         cwd: context.cwd,
         dangerouslySkipPermissions: true,
-        env: { DUST_UNATTENDED: "1", DUST_SKIP_AGENT: "1" },
+        env: baseEnv,
         signal
       },
       onRawEvent
@@ -2279,6 +2327,45 @@ async function loopClaude(dependencies, loopDependencies = createDefaultDependen
 // lib/bucket/repository-loop.ts
 var log2 = createLogger("dust:bucket:repository-loop");
 var FALLBACK_TIMEOUT_MS = 300000;
+function createLogCallbacks(logBuffer) {
+  return {
+    stdout: (msg) => appendLogLine(logBuffer, createLogLine(msg, "stdout")),
+    stderr: (msg) => appendLogLine(logBuffer, createLogLine(msg, "stderr"))
+  };
+}
+function flushAndLogMultiLine(partialLine, text, logBuffer) {
+  if (partialLine) {
+    appendLogLine(logBuffer, createLogLine(partialLine, "stdout"));
+  }
+  for (const segment of text.split(`
+`)) {
+    appendLogLine(logBuffer, createLogLine(segment, "stdout"));
+  }
+  return "";
+}
+function buildEventMessage(parameters) {
+  const msg = {
+    sequence: parameters.sequence,
+    timestamp: new Date().toISOString(),
+    sessionId: parameters.sessionId,
+    repository: parameters.repository,
+    event: parameters.event
+  };
+  if (parameters.agentSessionId) {
+    msg.agentSessionId = parameters.agentSessionId;
+  }
+  return msg;
+}
+function createWakeUpHandler(repoState, resolve) {
+  const handler = () => {
+    if (repoState.wakeUp !== handler) {
+      return;
+    }
+    repoState.wakeUp = undefined;
+    resolve();
+  };
+  return handler;
+}
 function createNoOpGlobScanner() {
   return {
     scan: async function* () {}
@@ -2288,12 +2375,13 @@ async function runRepositoryLoop(repoState, repoDeps, sendEvent, sessionId) {
   const { spawn, run: run2, fileSystem, sleep } = repoDeps;
   const repoName = repoState.repository.name;
   const settings = await loadSettings(repoState.path, fileSystem);
+  const logCallbacks = createLogCallbacks(repoState.logBuffer);
   const commandDeps = {
     arguments: [],
     context: {
       cwd: repoState.path,
-      stdout: (msg) => appendLogLine(repoState.logBuffer, createLogLine(msg, "stdout")),
-      stderr: (msg) => appendLogLine(repoState.logBuffer, createLogLine(msg, "stderr"))
+      stdout: (msg) => logCallbacks.stdout(msg),
+      stderr: (msg) => logCallbacks.stderr(msg)
     },
     fileSystem,
     globScanner: createNoOpGlobScanner(),
@@ -2313,14 +2401,7 @@ async function runRepositoryLoop(repoState, repoDeps, sendEvent, sessionId) {
         partialLine = lines[lines.length - 1];
       },
       line: (text) => {
-        if (partialLine) {
-          appendLogLine(repoState.logBuffer, createLogLine(partialLine, "stdout"));
-          partialLine = "";
-        }
-        for (const segment of text.split(`
-`)) {
-          appendLogLine(repoState.logBuffer, createLogLine(segment, "stdout"));
-        }
+        partialLine = flushAndLogMultiLine(partialLine, text, repoState.logBuffer);
       }
     })
   };
@@ -2351,17 +2432,13 @@ async function runRepositoryLoop(repoState, repoDeps, sendEvent, sessionId) {
     }
     if (sendEvent && sessionId) {
       sequence++;
-      const msg = {
+      sendEvent(buildEventMessage({
         sequence,
-        timestamp: new Date().toISOString(),
         sessionId,
         repository: repoName,
-        event
-      };
-      if (agentSessionId) {
-        msg.agentSessionId = agentSessionId;
-      }
-      sendEvent(msg);
+        event,
+        agentSessionId
+      }));
     }
   };
   const hooksInstalled = await manageGitHooks(commandDeps);
@@ -2379,6 +2456,7 @@ async function runRepositoryLoop(repoState, repoDeps, sendEvent, sessionId) {
       result = await runOneIteration(commandDeps, loopDeps, onLoopEvent, onAgentEvent, {
         hooksInstalled,
         signal: abortController.signal,
+        repositoryId: repoState.repository.id,
         onRawEvent: (rawEvent) => {
           onAgentEvent(rawEventToAgentEvent(rawEvent));
         }
@@ -2404,13 +2482,7 @@ async function runRepositoryLoop(repoState, repoDeps, sendEvent, sessionId) {
       log2(`${repoName}: no tasks available, waiting`);
       logLine("Waiting for tasks...");
       await new Promise((resolve) => {
-        const wakeUpForThisWait = () => {
-          if (repoState.wakeUp !== wakeUpForThisWait) {
-            return;
-          }
-          repoState.wakeUp = undefined;
-          resolve();
-        };
+        const wakeUpForThisWait = createWakeUpHandler(repoState, resolve);
         repoState.wakeUp = wakeUpForThisWait;
         sleep(FALLBACK_TIMEOUT_MS).then(() => {
           if (repoState.wakeUp === wakeUpForThisWait) {
@@ -2456,6 +2528,9 @@ function parseRepository(data) {
       if (typeof repositoryData.url === "string") {
         repo.url = repositoryData.url;
       }
+      if (typeof repositoryData.id === "string") {
+        repo.id = repositoryData.id;
+      }
       return repo;
     }
   }
@@ -3019,36 +3094,6 @@ function defaultGetTerminalSize() {
 function defaultWriteStdout(data) {
   process.stdout.write(data);
 }
-function defaultCreateServer(handler) {
-  let resolvedPort = 0;
-  const server = httpCreateServer(async (nodeRequest, nodeResponse) => {
-    const url = new URL(nodeRequest.url ?? "/", `http://localhost:${resolvedPort}`);
-    const request = new Request(url.toString(), {
-      method: nodeRequest.method ?? "GET"
-    });
-    const response = handler(request);
-    const body = await response.text();
-    nodeResponse.writeHead(response.status, {
-      "Content-Type": response.headers.get("content-type") ?? "text/plain"
-    });
-    nodeResponse.end(body);
-  });
-  server.listen(0, () => {
-    const addr2 = server.address();
-    if (addr2 && typeof addr2 === "object") {
-      resolvedPort = addr2.port;
-    }
-  });
-  const addr = server.address();
-  if (addr && typeof addr === "object") {
-    resolvedPort = addr.port;
-  }
-  return { port: resolvedPort, stop: () => server.close() };
-}
-function defaultOpenBrowser(url) {
-  const cmd = process.platform === "darwin" ? "open" : "xdg-open";
-  nodeSpawn3(cmd, [url], { stdio: "ignore", detached: true }).unref();
-}
 function createAuthFileSystem(dependencies) {
   return {
     exists: (path) => {
@@ -3087,7 +3132,7 @@ function createDefaultBucketDependencies() {
     rename: (oldPath, newPath) => import("node:fs/promises").then((mod) => mod.rename(oldPath, newPath))
   });
   return {
-    spawn: nodeSpawn3,
+    spawn: nodeSpawn4,
     createWebSocket: defaultCreateWebSocket,
     setupKeypress: defaultSetupKeypress,
     setupSignals: defaultSetupSignals,
@@ -3098,8 +3143,8 @@ function createDefaultBucketDependencies() {
     sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
     getReposDir: () => getReposDir(process.env, homedir()),
     auth: {
-      createServer: defaultCreateServer,
-      openBrowser: defaultOpenBrowser,
+      createServer: createLocalServer,
+      openBrowser,
       getHomeDir: () => homedir(),
       fileSystem: authFileSystem
     }
@@ -3464,6 +3509,176 @@ async function bucket(dependencies, bucketDeps = createDefaultBucketDependencies
   return { exitCode: 0 };
 }
 
+// lib/cli/commands/bucket-asset-upload.ts
+import { accessSync as accessSync2, statSync as statSync2 } from "node:fs";
+import { chmod as chmod2, mkdir as mkdir2, readdir as readdir2, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { extname } from "node:path";
+var MAX_FILE_SIZE_BYTES = 10 * 1024 * 1024;
+var ALLOWED_EXTENSIONS = new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".webp",
+  ".svg",
+  ".pdf",
+  ".txt",
+  ".json",
+  ".csv",
+  ".md",
+  ".html",
+  ".xml"
+]);
+var MIME_TYPES = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".pdf": "application/pdf",
+  ".txt": "text/plain",
+  ".json": "application/json",
+  ".csv": "text/csv",
+  ".md": "text/markdown",
+  ".html": "text/html",
+  ".xml": "application/xml"
+};
+function createDefaultUploadDependencies() {
+  const authFileSystemDeps = {
+    accessSync: accessSync2,
+    statSync: statSync2,
+    readFile: readFile2,
+    writeFile: writeFile2,
+    mkdir: mkdir2,
+    readdir: readdir2,
+    chmod: chmod2,
+    rename: (oldPath, newPath) => import("node:fs/promises").then((mod) => mod.rename(oldPath, newPath))
+  };
+  const authFileSystem = createAuthFileSystem(authFileSystemDeps);
+  return {
+    auth: {
+      createServer: createLocalServer,
+      openBrowser,
+      getHomeDir: () => homedir2(),
+      fileSystem: authFileSystem
+    },
+    readFileBytes: async (path) => {
+      const buffer = await Bun.file(path).arrayBuffer();
+      return new Uint8Array(buffer);
+    },
+    getFileSize: async (path) => {
+      const file = Bun.file(path);
+      return file.size;
+    },
+    fileExists: async (path) => {
+      const file = Bun.file(path);
+      return file.exists();
+    },
+    uploadFile: async (url, token, fileBytes, contentType) => {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "Content-Type": contentType
+        },
+        body: new Blob([fileBytes])
+      });
+      if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`Upload failed (${response.status}): ${text || response.statusText}`);
+      }
+      const body = await response.json();
+      if (typeof body.url !== "string") {
+        throw new Error("Server response missing URL");
+      }
+      return { url: body.url };
+    }
+  };
+}
+async function resolveToken2(authDeps, context) {
+  const envToken = process.env.DUST_BUCKET_TOKEN;
+  if (envToken) {
+    return envToken;
+  }
+  const stored = await loadStoredToken(authDeps.fileSystem, authDeps.getHomeDir());
+  if (stored) {
+    return stored;
+  }
+  context.stdout("Opening browser to authenticate with dustbucket...");
+  try {
+    const token = await authenticate(authDeps);
+    await storeToken(authDeps.fileSystem, authDeps.getHomeDir(), token);
+    context.stdout("Authenticated successfully");
+    return token;
+  } catch (error) {
+    context.stderr(`Authentication failed: ${error.message}`);
+    return null;
+  }
+}
+function getContentType(filePath) {
+  const ext = extname(filePath).toLowerCase();
+  return MIME_TYPES[ext] || "application/octet-stream";
+}
+function isAllowedExtension(filePath) {
+  const ext = extname(filePath).toLowerCase();
+  return ALLOWED_EXTENSIONS.has(ext);
+}
+function formatFileSize(bytes) {
+  if (bytes < 1024)
+    return `${bytes} bytes`;
+  if (bytes < 1048576)
+    return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / 1048576).toFixed(1)} MB`;
+}
+async function bucketAssetUpload(dependencies, uploadDeps = createDefaultUploadDependencies(), env = process.env) {
+  const { context } = dependencies;
+  const filePath = dependencies.arguments[0];
+  if (!filePath) {
+    context.stderr("Usage: dust bucket asset upload <file-path>");
+    return { exitCode: 1 };
+  }
+  const repositoryId = env.DUST_REPOSITORY_ID;
+  if (!repositoryId) {
+    context.stderr("Error: DUST_REPOSITORY_ID environment variable is not set.");
+    context.stderr("This command must be run within a repository context (via `dust bucket`).");
+    return { exitCode: 1 };
+  }
+  const exists = await uploadDeps.fileExists(filePath);
+  if (!exists) {
+    context.stderr(`File not found: ${filePath}`);
+    return { exitCode: 1 };
+  }
+  if (!isAllowedExtension(filePath)) {
+    const ext = extname(filePath).toLowerCase() || "(no extension)";
+    const allowed = Array.from(ALLOWED_EXTENSIONS).join(", ");
+    context.stderr(`Unsupported file type: ${ext}`);
+    context.stderr(`Allowed types: ${allowed}`);
+    return { exitCode: 1 };
+  }
+  const fileSize = await uploadDeps.getFileSize(filePath);
+  if (fileSize > MAX_FILE_SIZE_BYTES) {
+    context.stderr(`File too large: ${formatFileSize(fileSize)} (max ${formatFileSize(MAX_FILE_SIZE_BYTES)})`);
+    return { exitCode: 1 };
+  }
+  const token = await resolveToken2(uploadDeps.auth, context);
+  if (!token) {
+    return { exitCode: 1 };
+  }
+  const fileBytes = await uploadDeps.readFileBytes(filePath);
+  const contentType = getContentType(filePath);
+  const uploadUrl = `${getDustbucketHost()}/api/assets?repositoryId=${encodeURIComponent(repositoryId)}`;
+  try {
+    const result = await uploadDeps.uploadFile(uploadUrl, token, fileBytes, contentType);
+    context.stdout(result.url);
+    return { exitCode: 0 };
+  } catch (error) {
+    context.stderr(`Upload failed: ${error.message}`);
+    return { exitCode: 1 };
+  }
+}
+
 // lib/cli/process-runner.ts
 import { spawn } from "node:child_process";
 function createShellRunner(spawnFn) {
@@ -4710,10 +4925,10 @@ async function list(dependencies) {
 }
 
 // lib/codex/spawn-codex.ts
-import { spawn as nodeSpawn4 } from "node:child_process";
+import { spawn as nodeSpawn5 } from "node:child_process";
 import { createInterface as nodeCreateInterface2 } from "node:readline";
 var defaultDependencies2 = {
-  spawn: nodeSpawn4,
+  spawn: nodeSpawn5,
   createInterface: nodeCreateInterface2
 };
 async function* spawnCodex(prompt, options = {}, dependencies = defaultDependencies2) {
@@ -5232,6 +5447,7 @@ var commandRegistry = {
   agent,
   audit,
   bucket,
+  "bucket asset upload": bucketAssetUpload,
   focus,
   "new task": newTask,
   "new principle": newPrinciple,
@@ -5320,10 +5536,10 @@ function createFileSystem(primitives) {
     rename: (oldPath, newPath) => primitives.rename(oldPath, newPath)
   };
 }
-function createGlobScanner(readdir2) {
+function createGlobScanner(readdir3) {
   return {
     scan: async function* (dir) {
-      for (const entry of await readdir2(dir, { recursive: true })) {
+      for (const entry of await readdir3(dir, { recursive: true })) {
         if (entry.endsWith(".md"))
           yield entry;
       }
@@ -5350,7 +5566,7 @@ async function wireEntry(fsPrimitives, processPrimitives, consolePrimitives) {
 }
 
 // lib/cli/run.ts
-await wireEntry({ existsSync, statSync: statSync2, readFile: readFile2, writeFile: writeFile2, mkdir: mkdir2, readdir: readdir2, chmod: chmod2, rename }, {
+await wireEntry({ existsSync, statSync: statSync3, readFile: readFile3, writeFile: writeFile3, mkdir: mkdir3, readdir: readdir3, chmod: chmod3, rename }, {
   argv: process.argv,
   cwd: () => process.cwd(),
   exit: (code) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@joshski/dust",
-  "version": "0.1.63",
+  "version": "0.1.64",
   "description": "Flow state for AI coding agents",
   "type": "module",
   "bin": {