@slock-ai/daemon 0.41.1-alpha.0 → 0.42.0

package/dist/cli/index.js

@@ -159,6 +159,7 @@ var ApiClient = class {
   async parseJsonResponse(res) {
     let data = null;
     let error = null;
+    let errorCode = null;
     const contentType = res.headers.get("content-type") ?? "";
     if (contentType.includes("application/json")) {
       const parsed = await res.json().catch(() => null);
@@ -166,11 +167,12 @@ var ApiClient = class {
         data = parsed;
       } else {
         error = parsed?.error ?? `HTTP ${res.status}`;
+        errorCode = parsed?.errorCode ?? null;
       }
     } else if (!res.ok) {
       error = `HTTP ${res.status}`;
     }
-    return { ok: res.ok, status: res.status, data, error };
+    return { ok: res.ok, status: res.status, data, error, errorCode };
   }
   async request(method, pathname, body) {
     const url = new URL(pathname, this.ctx.serverUrl).toString();
@@ -229,11 +231,32 @@ var ApiClient = class {
 };
 
 // src/commands/server/_format.ts
+function formatRuntimeContext(ctx) {
+  if (!ctx) return "";
+  const lines = [
+    "### Current Runtime",
+    "Authoritative context for this agent process. Do not infer computer identity from hostname or cwd when this section is present."
+  ];
+  if (ctx.agentId) lines.push(`- Agent ID: ${ctx.agentId}`);
+  if (ctx.serverId) lines.push(`- Server ID: ${ctx.serverId}`);
+  if (ctx.machineName || ctx.machineId) {
+    const label = ctx.machineName && ctx.machineId ? `${ctx.machineName} (${ctx.machineId})` : ctx.machineName || ctx.machineId;
+    lines.push(`- Computer: ${label}`);
+  }
+  if (ctx.machineHostname) lines.push(`- Hostname: ${ctx.machineHostname}`);
+  if (ctx.machineOs) lines.push(`- OS: ${ctx.machineOs}`);
+  if (ctx.daemonVersion) lines.push(`- Daemon: v${ctx.daemonVersion}`);
+  if (ctx.workspacePath) lines.push(`- Workspace: ${ctx.workspacePath}`);
+  return lines.length > 2 ? `${lines.join("\n")}
+
+` : "";
+}
 function formatServerInfo(data) {
   let text = "## Server\n\n";
   const channels = data.channels ?? [];
   const agents = data.agents ?? [];
   const humans = data.humans ?? [];
+  text += formatRuntimeContext(data.runtimeContext);
   text += "### Channels\n";
   text += 'Visible public channels may appear even when `joined=false`. Use `slock message read --channel "#name"` to inspect them. When a channel is not joined, you cannot send messages there or receive ordinary channel delivery until a human adds you to the channel. To leave a channel you have joined, use `slock channel leave --target "#name"`. To stop following a thread, use `slock thread unfollow --target "#name:shortid"`.\n';
   if (channels.length > 0) {
@@ -348,7 +371,14 @@ function registerServerInfoCommand(parent) {
       const code = res.status >= 500 ? "SERVER_5XX" : "INFO_FAILED";
       fail(code, res.error ?? `HTTP ${res.status}`);
     }
-    process.stdout.write(formatServerInfo(res.data));
+    const data = res.data;
+    if (data?.runtimeContext) {
+      data.runtimeContext = {
+        ...data.runtimeContext,
+        workspacePath: data.runtimeContext.workspacePath ?? process.env.SLOCK_CURRENT_WORKSPACE_PATH ?? null
+      };
+    }
+    process.stdout.write(formatServerInfo(data));
   });
 }
 
@@ -826,11 +856,67 @@ function registerSearchCommand(parent) {
 import { existsSync, statSync, readFileSync } from "fs";
 import { basename } from "path";
 var MAX_BYTES = 10 * 1024 * 1024;
+var FILENAME_MIME_MAP = {
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".pdf": "application/pdf",
+  ".txt": "text/plain",
+  ".md": "text/markdown",
+  ".json": "application/json",
+  ".csv": "text/csv"
+};
+var MIME_TYPE_RE = /^[a-z0-9][a-z0-9!#$&^_.+-]*\/[a-z0-9][a-z0-9!#$&^_.+-]*$/i;
+var AttachmentUploadArgError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "AttachmentUploadArgError";
+  }
+};
+function inferMimeTypeFromFilename(filename) {
+  const index = filename.lastIndexOf(".");
+  const ext = index >= 0 ? filename.slice(index).toLowerCase() : "";
+  return FILENAME_MIME_MAP[ext] || null;
+}
+function inferMimeTypeFromBuffer(buffer) {
+  if (buffer.length >= 8 && buffer.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))) {
+    return "image/png";
+  }
+  if (buffer.length >= 3 && buffer.subarray(0, 3).equals(Buffer.from([255, 216, 255]))) {
+    return "image/jpeg";
+  }
+  if (buffer.length >= 6) {
+    const header = buffer.subarray(0, 6).toString("ascii");
+    if (header === "GIF87a" || header === "GIF89a") return "image/gif";
+  }
+  if (buffer.length >= 12 && buffer.subarray(0, 4).toString("ascii") === "RIFF" && buffer.subarray(8, 12).toString("ascii") === "WEBP") {
+    return "image/webp";
+  }
+  return null;
+}
+function normalizeExplicitMimeType(mimeType) {
+  const normalized = mimeType?.trim().toLowerCase();
+  if (!normalized) return null;
+  if (!MIME_TYPE_RE.test(normalized)) {
+    throw new AttachmentUploadArgError(
+      "INVALID_ARG",
+      `--mime-type must look like type/subtype, got: ${mimeType}`
+    );
+  }
+  return normalized;
+}
+function inferUploadMimeType(filename, buffer, explicitMimeType) {
+  const explicit = normalizeExplicitMimeType(explicitMimeType);
+  return explicit || inferMimeTypeFromBuffer(buffer) || inferMimeTypeFromFilename(filename) || "application/octet-stream";
+}
 function registerAttachmentUploadCommand(parent) {
   parent.command("upload").description("Upload a local file as an attachment (max 10MB)").requiredOption("--path <filepath>", "Absolute path to the local file to upload").option(
     "--channel <target>",
     "Target where the attachment will be used: '#channel', 'dm:@peer', or thread variants. Required by the v0 server until channel-less uploads land."
-  ).action(async (opts) => {
+  ).option("--mime-type <type>", "Explicit MIME type override, e.g. image/png").action(async (opts) => {
     let ctx;
     try {
       ctx = loadAgentContext();
@@ -871,10 +957,21 @@ function registerAttachmentUploadCommand(parent) {
     const channelId = resolved.data.channelId;
     const buffer = readFileSync(opts.path);
     const filename = basename(opts.path);
-    const blob = new Blob([buffer]);
+    let explicitMimeType;
+    try {
+      explicitMimeType = normalizeExplicitMimeType(opts.mimeType);
+    } catch (err) {
+      if (err instanceof AttachmentUploadArgError) fail(err.code, err.message);
+      throw err;
+    }
+    const uploadMimeType = inferUploadMimeType(filename, buffer, explicitMimeType);
+    const blob = new Blob([buffer], { type: uploadMimeType });
     const form = new FormData();
     form.append("file", blob, filename);
     form.append("channelId", channelId);
+    if (explicitMimeType) {
+      form.append("mimeType", explicitMimeType);
+    }
     const res = await client.requestMultipart(
       "POST",
       `${agentPath}/upload`,
@@ -1145,6 +1242,394 @@ function registerTaskUpdateCommand(parent) {
   });
 }
 
+// ../shared/src/tracing/index.ts
+var DEFAULT_TRACE_FLAGS = "00";
+var TRACE_ID_HEX_LENGTH = 32;
+var SPAN_ID_HEX_LENGTH = 16;
+var TRACE_FLAGS_HEX_LENGTH = 2;
+var TRACE_ID_PATTERN = /^[0-9a-f]{32}$/;
+var SPAN_ID_PATTERN = /^[0-9a-f]{16}$/;
+var TRACE_FLAGS_PATTERN = /^[0-9a-f]{2}$/;
+function isTraceId(value) {
+  return TRACE_ID_PATTERN.test(value) && value !== "0".repeat(TRACE_ID_HEX_LENGTH);
+}
+function isSpanId(value) {
+  return SPAN_ID_PATTERN.test(value) && value !== "0".repeat(SPAN_ID_HEX_LENGTH);
+}
+function isTraceFlags(value) {
+  return TRACE_FLAGS_PATTERN.test(value);
+}
+function assertTraceContext(context) {
+  if (!isTraceId(context.traceId)) {
+    throw new Error(`Invalid traceId: expected ${TRACE_ID_HEX_LENGTH} lowercase hex chars`);
+  }
+  if (!isSpanId(context.spanId)) {
+    throw new Error(`Invalid spanId: expected ${SPAN_ID_HEX_LENGTH} lowercase hex chars`);
+  }
+  if (context.parentSpanId !== null && !isSpanId(context.parentSpanId)) {
+    throw new Error(`Invalid parentSpanId: expected null or ${SPAN_ID_HEX_LENGTH} lowercase hex chars`);
+  }
+  if (!isTraceFlags(context.traceFlags)) {
+    throw new Error(`Invalid traceFlags: expected ${TRACE_FLAGS_HEX_LENGTH} lowercase hex chars`);
+  }
+}
+function createTraceContext({
+  parent = null,
+  traceId,
+  spanId,
+  traceFlags,
+  traceIdGenerator = generateTraceId,
+  spanIdGenerator = generateSpanId
+} = {}) {
+  const context = {
+    traceId: traceId ?? parent?.traceId ?? traceIdGenerator(),
+    spanId: spanId ?? spanIdGenerator(),
+    parentSpanId: parent?.spanId ?? null,
+    traceFlags: traceFlags ?? parent?.traceFlags ?? DEFAULT_TRACE_FLAGS
+  };
+  assertTraceContext(context);
+  return context;
+}
+var NoopTracer = class {
+  startSpan(_name, options) {
+    return new NoopActiveSpan(createTraceContext({ parent: options.parent ?? null }));
+  }
+};
+var NoopActiveSpan = class {
+  context;
+  constructor(context) {
+    this.context = context;
+  }
+  addEvent() {
+  }
+  end() {
+  }
+};
+var noopTracer = new NoopTracer();
+function generateTraceId() {
+  return randomNonZeroHex(TRACE_ID_HEX_LENGTH);
+}
+function generateSpanId() {
+  return randomNonZeroHex(SPAN_ID_HEX_LENGTH);
+}
+function randomNonZeroHex(length) {
+  let value = randomHex(length);
+  while (value === "0".repeat(length)) {
+    value = randomHex(length);
+  }
+  return value;
+}
+function randomHex(length) {
+  const bytes = new Uint8Array(length / 2);
+  globalThis.crypto.getRandomValues(bytes);
+  return [...bytes].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+
+// ../shared/src/testing/failpoints.ts
+var NoopFailpointRegistry = class {
+  get enabled() {
+    return false;
+  }
+  isEnabled() {
+    return false;
+  }
+  configure() {
+  }
+  clear() {
+  }
+  getTrace() {
+    return [];
+  }
+  hit(_key, _context, fallback) {
+    return fallback ? fallback() : void 0;
+  }
+};
+var noopFailpointRegistry = new NoopFailpointRegistry();
+
+// ../shared/src/serverPermissions.ts
+var EMPTY_SERVER_CAPABILITIES = Object.freeze({
+  manageServer: false,
+  manageChannels: false,
+  manageAgents: false,
+  manageMachines: false,
+  manageMembers: false,
+  changeMemberRoles: false,
+  manageBilling: false,
+  joinPublicChannels: false
+});
+var SERVER_CAPABILITY_MATRIX = {
+  owner: Object.freeze({
+    manageServer: true,
+    manageChannels: true,
+    manageAgents: true,
+    manageMachines: true,
+    manageMembers: true,
+    changeMemberRoles: true,
+    manageBilling: true,
+    joinPublicChannels: true
+  }),
+  admin: Object.freeze({
+    manageServer: true,
+    manageChannels: true,
+    manageAgents: true,
+    manageMachines: true,
+    manageMembers: true,
+    changeMemberRoles: true,
+    manageBilling: false,
+    joinPublicChannels: true
+  }),
+  member: Object.freeze({
+    manageServer: false,
+    manageChannels: false,
+    manageAgents: false,
+    manageMachines: false,
+    manageMembers: false,
+    changeMemberRoles: false,
+    manageBilling: false,
+    joinPublicChannels: true
+  })
+};
+
+// ../shared/src/index.ts
+var RUNTIMES = [
+  { id: "claude", displayName: "Claude Code", binary: "claude", supported: true },
+  { id: "codex", displayName: "Codex CLI", binary: "codex", supported: true },
+  { id: "kimi", displayName: "Kimi CLI", binary: "kimi", supported: true },
+  { id: "copilot", displayName: "Copilot CLI", binary: "copilot", supported: true },
+  { id: "cursor", displayName: "Cursor CLI", binary: "cursor-agent", supported: true },
+  { id: "gemini", displayName: "Gemini CLI", binary: "gemini", supported: true }
+];
+function getRuntimeDisplayName(id) {
+  return RUNTIMES.find((r) => r.id === id)?.displayName ?? id;
+}
+var PLAN_CONFIG = {
+  free: {
+    displayName: "Hobby",
+    limits: { maxMachines: 2, maxAgents: 5, maxChannels: 5, messageHistoryDays: 30, includedAgents: 5 },
+    comingSoon: false,
+    price: 0,
+    extraAgentPrice: 0
+  },
+  founder: {
+    displayName: "Founder",
+    limits: { maxMachines: -1, maxAgents: -1, maxChannels: -1, messageHistoryDays: -1, includedAgents: -1 },
+    comingSoon: false,
+    price: 0,
+    extraAgentPrice: 0
+  }
+};
+var DISPLAY_PLAN_CONFIG = {
+  free: PLAN_CONFIG.free,
+  pro: {
+    displayName: "Team",
+    limits: { maxMachines: 8, maxAgents: 40, maxChannels: 20, messageHistoryDays: -1, includedAgents: 40 },
+    comingSoon: true,
+    price: 20,
+    extraAgentPrice: 0
+  },
+  max: {
+    displayName: "Business",
+    limits: { maxMachines: 40, maxAgents: 200, maxChannels: -1, messageHistoryDays: -1, includedAgents: 200 },
+    comingSoon: true,
+    price: 200,
+    extraAgentPrice: 0
+  }
+};
+
+// src/commands/profile/_format.ts
+function formatCreatedAgents(createdAgents) {
+  if (createdAgents.length === 0) {
+    return ["- Created Agents: none"];
+  }
+  return [
+    `- Created Agents (${createdAgents.length}):`,
+    ...createdAgents.map((createdAgent) => `  - @${createdAgent.name} (${getRuntimeDisplayName(createdAgent.runtime)}, ${createdAgent.status})`)
+  ];
+}
+function formatHumanProfile(profile) {
+  const lines = [
+    "## Profile",
+    "",
+    "- Type: human",
+    `- Handle: @${profile.name}`,
+    `- Display Name: ${profile.displayName ?? "(none)"}`,
+    `- Description: ${profile.description ?? "(none)"}`,
+    `- Membership: ${profile.membershipStatus}`
+  ];
+  if (profile.role) lines.push(`- Role: ${profile.role}`);
+  if (profile.joinedAt) lines.push(`- Joined: ${profile.joinedAt}`);
+  if (profile.email) lines.push(`- Email: ${profile.email}`);
+  return [...lines, ...formatCreatedAgents(profile.createdAgents)].join("\n");
+}
+function formatCreator(profile) {
+  if (!profile.creator) return null;
+  return profile.creator.displayName ? `${profile.creator.displayName} (@${profile.creator.name})` : `@${profile.creator.name}`;
+}
+function formatAgentProfile(profile) {
+  const lines = [
+    "## Profile",
+    "",
+    "- Type: agent",
+    `- Handle: @${profile.name}`,
+    `- Display Name: ${profile.displayName ?? "(none)"}`,
+    `- Description: ${profile.description ?? "(none)"}`,
+    `- Status: ${profile.status}`,
+    `- Runtime: ${getRuntimeDisplayName(profile.runtime)}`,
+    `- Model: ${profile.model}`,
+    `- Reasoning: ${profile.reasoningEffort ?? "medium"}`
+  ];
+  if (profile.executionMode) lines.push(`- Execution: ${profile.executionMode}`);
+  if (profile.computerName || profile.computerId) {
+    const label = profile.computerName && profile.computerId ? `${profile.computerName} (${profile.computerId})` : profile.computerName ?? profile.computerId;
+    lines.push(`- Computer: ${label}`);
+  }
+  if (profile.computerHostname) lines.push(`- Hostname: ${profile.computerHostname}`);
+  if (profile.daemonVersion) lines.push(`- Daemon: v${profile.daemonVersion}`);
+  lines.push(`- Created: ${profile.createdAt}`);
+  if (profile.deletedAt) lines.push(`- Deleted At: ${profile.deletedAt}`);
+  const creator = formatCreator(profile);
+  if (creator) lines.push(`- Creator: ${creator}`);
+  return [...lines, ...formatCreatedAgents(profile.createdAgents)].join("\n");
+}
+function formatProfile(profile) {
+  return profile.kind === "human" ? formatHumanProfile(profile) : formatAgentProfile(profile);
+}
+
+// src/commands/profile/show.ts
+function normalizeTarget(target) {
+  if (target === void 0) return null;
+  const trimmed = target.trim();
+  if (!trimmed) {
+    fail("INVALID_ARG", "profile target must not be empty");
+  }
+  if (!trimmed.startsWith("@")) {
+    fail("INVALID_ARG", "profile target must start with @");
+  }
+  return trimmed;
+}
+function registerProfileShowCommand(parent) {
+  parent.command("show").description("Show a profile. Omit the target to show your own profile.").argument("[target]", "Handle like @alice; omit to show your own profile").option("--json", "Emit machine-readable JSON").action(async (target, opts) => {
+    let ctx;
+    try {
+      ctx = loadAgentContext();
+    } catch (err) {
+      if (err instanceof AgentBootstrapError) fail(err.code, err.message);
+      throw err;
+    }
+    const normalizedTarget = normalizeTarget(target);
+    const params = new URLSearchParams();
+    if (normalizedTarget) params.set("target", normalizedTarget);
+    const client = new ApiClient(ctx);
+    const pathname = params.size > 0 ? `/internal/agent/${encodeURIComponent(ctx.agentId)}/profile?${params.toString()}` : `/internal/agent/${encodeURIComponent(ctx.agentId)}/profile`;
+    const res = await client.request("GET", pathname);
+    if (!res.ok || !res.data) {
+      const code = res.status >= 500 ? "SERVER_5XX" : "PROFILE_SHOW_FAILED";
+      fail(code, res.error ?? `HTTP ${res.status}`);
+    }
+    if (opts.json) {
+      emit({ ok: true, data: res.data });
+      return;
+    }
+    process.stdout.write(`${formatProfile(res.data)}
+`);
+  });
+}
+
+// src/commands/profile/update.ts
+import { basename as basename2 } from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync2, statSync as statSync2 } from "fs";
+var MAX_PROFILE_AVATAR_BYTES = 2 * 1024 * 1024;
+var PROFILE_AVATAR_MIME_TYPES = /* @__PURE__ */ new Set([
+  "image/jpeg",
+  "image/png",
+  "image/gif",
+  "image/webp"
+]);
+var FILENAME_MIME_MAP2 = {
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".gif": "image/gif",
+  ".webp": "image/webp"
+};
+function inferImageMimeType(filename, buffer) {
+  const lowerFilename = filename.toLowerCase();
+  if (buffer.length >= 8 && buffer.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))) {
+    return "image/png";
+  }
+  if (buffer.length >= 3 && buffer.subarray(0, 3).equals(Buffer.from([255, 216, 255]))) {
+    return "image/jpeg";
+  }
+  if (buffer.length >= 6) {
+    const header = buffer.subarray(0, 6).toString("ascii");
+    if (header === "GIF87a" || header === "GIF89a") return "image/gif";
+  }
+  if (buffer.length >= 12 && buffer.subarray(0, 4).toString("ascii") === "RIFF" && buffer.subarray(8, 12).toString("ascii") === "WEBP") {
+    return "image/webp";
+  }
+  const dot = lowerFilename.lastIndexOf(".");
+  return dot >= 0 ? FILENAME_MIME_MAP2[lowerFilename.slice(dot)] ?? null : null;
+}
+function readAvatarFile(avatarFile) {
+  if (!existsSync2(avatarFile)) {
+    fail("PROFILE_FILE_NOT_FOUND", `Avatar file does not exist: ${avatarFile}`);
+  }
+  const stat = statSync2(avatarFile);
+  if (!stat.isFile()) {
+    fail("PROFILE_FILE_NOT_FOUND", `Avatar file is not a regular file: ${avatarFile}`);
+  }
+  if (stat.size > MAX_PROFILE_AVATAR_BYTES) {
+    fail(
+      "PROFILE_AVATAR_TOO_LARGE",
+      `Avatar file is ${stat.size} bytes; max size is ${MAX_PROFILE_AVATAR_BYTES} bytes`
+    );
+  }
+  const buffer = readFileSync2(avatarFile);
+  const filename = basename2(avatarFile);
+  const mimeType = inferImageMimeType(filename, buffer);
+  if (!mimeType || !PROFILE_AVATAR_MIME_TYPES.has(mimeType)) {
+    fail(
+      "PROFILE_AVATAR_BAD_FORMAT",
+      "Avatar must be a JPEG, PNG, GIF, or WebP image"
+    );
+  }
+  return { filename, buffer, mimeType };
+}
+function registerProfileUpdateCommand(parent) {
+  parent.command("update").description("Update your own profile").requiredOption("--avatar-file <path>", "Path to a local image file to use as your avatar").option("--json", "Emit machine-readable JSON").action(async (opts) => {
+    let ctx;
+    try {
+      ctx = loadAgentContext();
+    } catch (err) {
+      if (err instanceof AgentBootstrapError) fail(err.code, err.message);
+      throw err;
+    }
+    if (!opts.avatarFile) {
+      fail("INVALID_ARG", "--avatar-file is required");
+    }
+    const avatar = readAvatarFile(opts.avatarFile);
+    const form = new FormData();
+    const avatarBytes = Uint8Array.from(avatar.buffer);
+    form.append("avatar", new Blob([avatarBytes], { type: avatar.mimeType }), avatar.filename);
+    const client = new ApiClient(ctx);
+    const res = await client.requestMultipart(
+      "POST",
+      `/internal/agent/${encodeURIComponent(ctx.agentId)}/profile/avatar`,
+      form
+    );
+    if (!res.ok || !res.data) {
+      const code = res.errorCode ?? (res.status >= 500 ? "SERVER_5XX" : "PROFILE_UPDATE_FAILED");
+      fail(code, res.error ?? `HTTP ${res.status}`);
+    }
+    if (opts.json) {
+      emit({ ok: true, data: res.data });
+      return;
+    }
+    process.stdout.write(`${formatProfile(res.data)}
+`);
+  });
+}
+
 // src/commands/reminder/_format.ts
 function toLocalTime2(iso) {
   const d = new Date(iso);
@@ -1369,6 +1854,9 @@ registerTaskCreateCommand(taskCmd);
 registerTaskClaimCommand(taskCmd);
 registerTaskUnclaimCommand(taskCmd);
 registerTaskUpdateCommand(taskCmd);
+var profileCmd = program.command("profile").description("Profile operations");
+registerProfileShowCommand(profileCmd);
+registerProfileUpdateCommand(profileCmd);
 var reminderCmd = program.command("reminder").description("Reminder operations");
 registerReminderScheduleCommand(reminderCmd);
 registerReminderListCommand(reminderCmd);

package/dist/core.js

@@ -9,7 +9,7 @@ import {
   resolveSlockCliPath,
   resolveWorkspaceDirectoryPath,
   scanWorkspaceDirectories
-} from "./chunk-JAB3HALZ.js";
+} from "./chunk-RNEIFBXW.js";
 import {
   subscribeDaemonLogs
 } from "./chunk-JG7ONJZ6.js";

package/dist/index.js

@@ -3,7 +3,7 @@ import {
   DAEMON_CLI_USAGE,
   DaemonCore,
   parseDaemonCliArgs
-} from "./chunk-JAB3HALZ.js";
+} from "./chunk-RNEIFBXW.js";
 import "./chunk-JG7ONJZ6.js";
 
 // src/index.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slock-ai/daemon",
-  "version": "0.41.1-alpha.0",
+  "version": "0.42.0",
   "type": "module",
   "bin": {
     "slock-daemon": "dist/index.js"