@alook/cli 0.0.3 → 0.0.4

package/dist/index.js

@@ -15,7 +15,7 @@ var __export = (target, all) => {
 };
 
 // src/index.ts
-import { Command as Command7 } from "commander";
+import { Command as Command8 } from "commander";
 
 // commands/register.ts
 import { Command } from "commander";
@@ -64,6 +64,25 @@ class APIClient {
   patchJSON(path, body) {
     return this.request("PATCH", path, body);
   }
+  async postMultipart(path, form) {
+    const headers = {
+      Authorization: `Bearer ${this.token}`
+    };
+    if (this.workspaceId)
+      headers["X-Workspace-ID"] = this.workspaceId;
+    const res = await fetch(this.baseURL + path, {
+      method: "POST",
+      headers,
+      body: form
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`HTTP ${res.status}: ${text}`);
+    }
+    if (res.status === 204)
+      return;
+    return res.json();
+  }
   async getText(path) {
     const headers = {
       Authorization: `Bearer ${this.token}`
@@ -281,6 +300,11 @@ import { openSync, closeSync, mkdirSync as mkdirSync3 } from "fs";
 import { dirname as dirname3 } from "path";
 
 // ../shared/src/constants.ts
+var TASK_TYPES = {
+  USER_DM_MESSAGE: "user_dm_message",
+  EMAIL_NOTIFICATION: "email_notification",
+  CALENDAR_EVENT: "calendar_event"
+};
 var POLL_INTERVAL_MS = Number(process.env.POLL_INTERVAL_MS) || 3000;
 var OFFLINE_THRESHOLD_MS = Number(process.env.OFFLINE_THRESHOLD_MS) || 9000;
 var EVENT_POLL_INTERVAL_MS = Number(process.env.EVENT_POLL_INTERVAL_MS) || 2000;
@@ -13839,7 +13863,7 @@ var ClaimedTaskRowSchema = exports_external.object({
   priority: exports_external.coerce.number(),
   result: exports_external.unknown().nullable(),
   context: exports_external.unknown().nullable(),
-  type: exports_external.string().default("user_dm_message"),
+  type: exports_external.string().default(TASK_TYPES.USER_DM_MESSAGE),
   sessionId: exports_external.string().nullable(),
   createdAt: exports_external.coerce.date(),
   dispatchedAt: exports_external.coerce.date().nullable(),
@@ -13932,6 +13956,50 @@ var MessageItemSchema = exports_external.object({
 var ReportMessagesRequestSchema = exports_external.object({
   messages: exports_external.array(MessageItemSchema)
 });
+var RepeatIntervalSchema = exports_external.string().regex(/^\d+(min|hour|day|week|month)$/, {
+  message: "repeat_interval must match <positive_integer><min|hour|day|week|month>"
+});
+var CreateCalendarEventRequestSchema = exports_external.object({
+  agent_id: exports_external.string().min(1),
+  title: exports_external.string().min(1),
+  description: exports_external.string().max(20000).optional(),
+  scheduled_at: exports_external.string().min(1).refine((s) => !Number.isNaN(Date.parse(s)), {
+    message: "scheduled_at must be a valid ISO datetime"
+  }),
+  repeat_interval: RepeatIntervalSchema.optional(),
+  repeat_stop_date: exports_external.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional()
+}).refine((data) => !data.repeat_stop_date || !!data.repeat_interval, {
+  message: "repeat_stop_date requires repeat_interval",
+  path: ["repeat_stop_date"]
+});
+var UpdateCalendarEventRequestSchema = exports_external.object({
+  title: exports_external.string().min(1).optional(),
+  description: exports_external.string().max(20000).nullable().optional(),
+  agent_id: exports_external.string().min(1).optional(),
+  scheduled_at: exports_external.string().min(1).refine((s) => !Number.isNaN(Date.parse(s)), {
+    message: "scheduled_at must be a valid ISO datetime"
+  }).optional(),
+  repeat_interval: RepeatIntervalSchema.nullable().optional(),
+  repeat_stop_date: exports_external.string().regex(/^\d{4}-\d{2}-\d{2}$/).nullable().optional(),
+  scope: exports_external.enum(["this", "following"]).optional(),
+  occurrence_at: exports_external.string().min(1).refine((s) => !Number.isNaN(Date.parse(s)), {
+    message: "occurrence_at must be a valid ISO datetime"
+  }).optional()
+}).refine((v) => v.title !== undefined || v.description !== undefined || v.agent_id !== undefined || v.scheduled_at !== undefined || v.repeat_interval !== undefined || v.repeat_stop_date !== undefined, { message: "at least one field is required" });
+var CalendarEventApiSchema = exports_external.object({
+  id: exports_external.string(),
+  agent_id: exports_external.string(),
+  workspace_id: exports_external.string(),
+  title: exports_external.string(),
+  description: exports_external.string().nullable(),
+  scheduled_at: exports_external.string(),
+  occurrence_at: exports_external.string(),
+  repeat_interval: exports_external.string().nullable(),
+  repeat_stop_at: exports_external.string().nullable(),
+  last_triggered_at: exports_external.string().nullable(),
+  created_at: exports_external.string(),
+  updated_at: exports_external.string()
+});
 // ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@4.20260414.1_@opentelemetry+api@1.9.1_bun-types@1.3.12_kysely@0.28.15/node_modules/drizzle-orm/entity.js
 var entityKind = Symbol.for("drizzle:entityKind");
 var hasOwnEntityKind = Symbol.for("drizzle:hasOwnEntityKind");
@@ -15424,6 +15492,7 @@ var conversation = sqliteTable("conversation", {
   agentId: text("agent_id").notNull(),
   userId: text("user_id").notNull().references(() => user.id, { onDelete: "cascade" }),
   title: text("title").notNull().default(""),
+  type: text("type").notNull().default(TASK_TYPES.USER_DM_MESSAGE),
   createdAt: text("created_at").notNull().$defaultFn(() => new Date().toISOString())
 }, (t) => [
   foreignKey({
@@ -15446,7 +15515,7 @@ var agentTaskQueue = sqliteTable("agent_task_queue", {
   workspaceId: text("workspace_id").notNull().references(() => workspace.id),
   conversationId: text("conversation_id").notNull().references(() => conversation.id),
   prompt: text("prompt").notNull(),
-  type: text("type").notNull().default("user_dm_message"),
+  type: text("type").notNull().default(TASK_TYPES.USER_DM_MESSAGE),
   status: text("status").notNull().default("queued"),
   priority: integer2("priority").notNull().default(0),
   result: text("result", { mode: "json" }),
@@ -15496,6 +15565,27 @@ var emails = sqliteTable("emails", {
     foreignColumns: [agent.id, agent.workspaceId]
   }).onDelete("cascade")
 ]);
+var calendarEvent = sqliteTable("calendar_event", {
+  id: text("id").primaryKey().$defaultFn(() => "ce_" + nanoid3()),
+  agentId: text("agent_id").notNull(),
+  workspaceId: text("workspace_id").notNull(),
+  title: text("title").notNull(),
+  description: text("description"),
+  scheduledAt: text("scheduled_at").notNull(),
+  repeatInterval: text("repeat_interval"),
+  repeatStopAt: text("repeat_stop_at"),
+  lastTriggeredAt: text("last_triggered_at"),
+  exceptions: text("exceptions", { mode: "json" }).$type().notNull().default(sql`'[]'`),
+  createdAt: text("created_at").notNull().$defaultFn(() => new Date().toISOString()),
+  updatedAt: text("updated_at").notNull().$defaultFn(() => new Date().toISOString())
+}, (t) => [
+  index("idx_calendar_event_agent_ws").on(t.agentId, t.workspaceId),
+  index("idx_calendar_event_ws_scheduled").on(t.workspaceId, t.scheduledAt),
+  foreignKey({
+    columns: [t.agentId, t.workspaceId],
+    foreignColumns: [agent.id, agent.workspaceId]
+  }).onDelete("cascade")
+]);
 var machineToken = sqliteTable("machine_token", {
   id: text("id").primaryKey().$defaultFn(() => nanoid3()),
   userId: text("user_id").notNull().references(() => user.id, { onDelete: "cascade" }),
@@ -16224,11 +16314,37 @@ function configCommand() {
 
 // commands/email.ts
 import { Command as Command5 } from "commander";
-import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync4 } from "fs";
-import { join as join4 } from "path";
+import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync4, readFileSync as readFileSync3, statSync } from "fs";
+import { basename, join as join4 } from "path";
 import PostalMime from "postal-mime";
 var VALID_STATUSES = ["unread", "read", "archived"];
 var EMAIL_DIR = "/tmp/alook-emails";
+var MIME_BY_EXT = {
+  ".pdf": "application/pdf",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".txt": "text/plain",
+  ".html": "text/html",
+  ".htm": "text/html",
+  ".json": "application/json",
+  ".csv": "text/csv",
+  ".md": "text/markdown",
+  ".zip": "application/zip"
+};
+function guessContentType(filename) {
+  const idx = filename.lastIndexOf(".");
+  if (idx < 0)
+    return "application/octet-stream";
+  const ext = filename.slice(idx).toLowerCase();
+  return MIME_BY_EXT[ext] ?? "application/octet-stream";
+}
+function collectRepeated(value, previous) {
+  return previous.concat([value]);
+}
 function resolveClientOpts(command, opts) {
   const parentOpts = command.parent?.parent?.opts() || {};
   const profile = parentOpts.profile;
@@ -16362,14 +16478,278 @@ function emailCommand() {
       process.exit(1);
     }
   });
+  cmd.command("send").description("Send an email from the agent").requiredOption("--agent_id <id>", "Agent ID").requiredOption("--to <addr>", "Recipient email address").requiredOption("--subject <s>", "Subject line").requiredOption("--body-file <path>", "Path to HTML body file").option("--attachment <path>", "Path to a file to attach (repeatable)", collectRepeated, []).option("--workspace <id>", "Workspace ID").action(async (opts, command) => {
+    const { serverUrl, token, workspaceId } = resolveClientOpts(command, {
+      workspace: opts.workspace,
+      agentId: opts.agent_id
+    });
+    const client = new APIClient(serverUrl, token, workspaceId);
+    let htmlBody;
+    try {
+      htmlBody = readFileSync3(opts.bodyFile, "utf-8");
+    } catch (err) {
+      console.error(`Error: cannot read body file "${opts.bodyFile}": ${err instanceof Error ? err.message : err}`);
+      process.exit(1);
+    }
+    if (!htmlBody) {
+      console.error(`Error: body file "${opts.bodyFile}" is empty`);
+      process.exit(1);
+    }
+    const attachmentPaths = opts.attachment ?? [];
+    const attachments = [];
+    try {
+      for (const path of attachmentPaths) {
+        let bytes;
+        let size;
+        try {
+          bytes = readFileSync3(path);
+          size = statSync(path).size;
+        } catch (err) {
+          console.error(`Error: cannot read attachment "${path}": ${err instanceof Error ? err.message : err}`);
+          process.exit(1);
+        }
+        const filename = basename(path);
+        const contentType = guessContentType(filename);
+        const form = new FormData;
+        form.append("file", new Blob([new Uint8Array(bytes)], { type: contentType }), filename);
+        const uploaded = await client.postMultipart("/api/email/upload", form);
+        attachments.push({
+          key: uploaded.key,
+          filename: uploaded.filename,
+          size: uploaded.size ?? size,
+          contentType: uploaded.contentType ?? contentType
+        });
+      }
+      const res = await client.postJSON("/api/email/send", {
+        agentId: opts.agent_id,
+        to: opts.to,
+        subject: opts.subject,
+        htmlBody,
+        attachments
+      });
+      console.log(`Sent email to ${res.to_email} (id: ${res.id})`);
+    } catch (err) {
+      console.error(`Error: ${err instanceof Error ? err.message : err}`);
+      process.exit(1);
+    }
+  });
   return cmd;
 }
 
-// commands/version.ts
+// commands/calendar.ts
 import { Command as Command6 } from "commander";
+function resolveClientOpts2(command, agentId) {
+  const parentOpts = command.parent?.parent?.opts() || {};
+  const profile = parentOpts.profile;
+  const cfg = loadCLIConfigForProfile(profile);
+  const serverUrl = parentOpts.server || cfg.server_url;
+  const workspaces = cfg.watched_workspaces || [];
+  const ws = workspaces.find((w) => w.agent_ids?.includes(agentId));
+  if (!ws || !ws.token) {
+    console.error(`Error: no registered workspace contains agent ${agentId}. Run '${cmdPrefix()} register --token <token>' first.`);
+    process.exit(1);
+  }
+  return { serverUrl, token: ws.token, workspaceId: ws.id };
+}
+function parseLocalDatetime(input) {
+  const match = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})(?::(\d{2}))?$/.exec(input);
+  if (!match) {
+    throw new Error(`invalid --datetime "${input}" — expected YYYY-MM-DDTHH:MM`);
+  }
+  const [, y, mo, d, h, mi, s] = match;
+  const date5 = new Date(Number(y), Number(mo) - 1, Number(d), Number(h), Number(mi), s ? Number(s) : 0);
+  return date5.toISOString();
+}
+function formatLocalDatetime(iso) {
+  const d = new Date(iso);
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`;
+}
+function printEventDetail(ev) {
+  console.log(`id:            ${ev.id}`);
+  console.log(`agent_id:      ${ev.agent_id}`);
+  console.log(`title:         ${ev.title}`);
+  console.log(`scheduled_at:  ${formatLocalDatetime(ev.scheduled_at)}`);
+  if (ev.repeat_interval) {
+    const until = ev.repeat_stop_at ? ` until ${formatLocalDatetime(ev.repeat_stop_at)}` : "";
+    console.log(`repeat:        every ${ev.repeat_interval}${until}`);
+  } else {
+    console.log(`repeat:        (none)`);
+  }
+  console.log(`last_fired_at: ${ev.last_triggered_at ? formatLocalDatetime(ev.last_triggered_at) : "(never)"}`);
+  console.log("description:");
+  console.log(ev.description ?? "(no description)");
+}
+function calendarCommand() {
+  const cmd = new Command6("calendar").description("Manage scheduled agent events");
+  cmd.command("set").description("Create a calendar event").requiredOption("--agent_id <id>", "Agent ID").requiredOption("--event_title <title>", "Event title (used as the task prompt)").requiredOption("--datetime <iso>", "Scheduled datetime (YYYY-MM-DDTHH:MM, local time)").option("--description <text>", "Optional longer-form notes for the event").option("--repeat <interval>", "Repeat interval, e.g. 1day, 2hour, 1month").option("--repeat_stop_date <date>", "Stop repeating on or after this date (YYYY-MM-DD, local time)").option("--json", "Output as JSON").action(async (opts, command) => {
+    const { serverUrl, token, workspaceId } = resolveClientOpts2(command, opts.agent_id);
+    const client = new APIClient(serverUrl, token, workspaceId);
+    let scheduledAt;
+    try {
+      scheduledAt = parseLocalDatetime(opts.datetime);
+    } catch (err) {
+      console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+      process.exit(1);
+    }
+    if (opts.repeat_stop_date && !opts.repeat) {
+      console.error("Error: --repeat_stop_date requires --repeat");
+      process.exit(1);
+    }
+    if (opts.repeat_stop_date && !/^\d{4}-\d{2}-\d{2}$/.test(opts.repeat_stop_date)) {
+      console.error("Error: --repeat_stop_date must be YYYY-MM-DD");
+      process.exit(1);
+    }
+    const body = {
+      agent_id: opts.agent_id,
+      title: opts.event_title,
+      scheduled_at: scheduledAt
+    };
+    if (opts.description)
+      body.description = opts.description;
+    if (opts.repeat)
+      body.repeat_interval = opts.repeat;
+    if (opts.repeat_stop_date)
+      body.repeat_stop_date = opts.repeat_stop_date;
+    try {
+      const created = await client.postJSON("/api/calendar", body);
+      if (opts.json) {
+        printJSON(created);
+        return;
+      }
+      console.log(`Created ${created.id} — ${created.title} @ ${formatLocalDatetime(created.scheduled_at)}${created.repeat_interval ? ` (every ${created.repeat_interval})` : ""}`);
+    } catch (err) {
+      console.error(`Error: ${err instanceof Error ? err.message : err}`);
+      process.exit(1);
+    }
+  });
+  cmd.command("list").description("List calendar events for an agent").requiredOption("--agent_id <id>", "Agent ID").option("--future_days <n>", "Include events scheduled in the next N days", "30").option("--past_days <n>", "Include events scheduled in the past N days", "0").option("--json", "Output as JSON").action(async (opts, command) => {
+    const { serverUrl, token, workspaceId } = resolveClientOpts2(command, opts.agent_id);
+    const client = new APIClient(serverUrl, token, workspaceId);
+    const now = Date.now();
+    const from = new Date(now - Number(opts.past_days) * 86400000).toISOString();
+    const to = new Date(now + Number(opts.future_days) * 86400000).toISOString();
+    try {
+      const events = await client.getJSON(`/api/calendar?agentId=${encodeURIComponent(opts.agent_id)}&from=${encodeURIComponent(from)}&to=${encodeURIComponent(to)}`);
+      if (opts.json) {
+        printJSON(events);
+        return;
+      }
+      if (events.length === 0) {
+        console.log("No calendar events.");
+        return;
+      }
+      for (const ev of events) {
+        const repeatBadge = ev.repeat_interval ? ` [every ${ev.repeat_interval}${ev.repeat_stop_at ? ` until ${formatLocalDatetime(ev.repeat_stop_at)}` : ""}]` : "";
+        const descBadge = ev.description ? " [has description]" : "";
+        console.log(`${ev.id}  ${formatLocalDatetime(ev.scheduled_at)}  ${ev.title}${repeatBadge}${descBadge}`);
+      }
+    } catch (err) {
+      console.error(`Error: ${err instanceof Error ? err.message : err}`);
+      process.exit(1);
+    }
+  });
+  cmd.command("show").description("Show the full detail of a single calendar event").requiredOption("--agent_id <id>", "Agent ID").requiredOption("--event_id <id>", "Event ID").option("--json", "Output as JSON").action(async (opts, command) => {
+    const { serverUrl, token, workspaceId } = resolveClientOpts2(command, opts.agent_id);
+    const client = new APIClient(serverUrl, token, workspaceId);
+    try {
+      const ev = await client.getJSON(`/api/calendar/${opts.event_id}`);
+      if (ev.agent_id !== opts.agent_id) {
+        console.error(`Error: event ${ev.id} does not belong to agent ${opts.agent_id}`);
+        process.exit(1);
+      }
+      if (opts.json) {
+        printJSON(ev);
+        return;
+      }
+      printEventDetail(ev);
+    } catch (err) {
+      console.error(`Error: ${err instanceof Error ? err.message : err}`);
+      process.exit(1);
+    }
+  });
+  cmd.command("update").description("Update fields on an existing calendar event").requiredOption("--agent_id <id>", "Agent ID").requiredOption("--event_id <id>", "Event ID").option("--event_title <title>", "New event title (task prompt)").option("--description <text>", "New description text").option("--clear_description", "Remove the description (sets to null)").option("--datetime <iso>", "New scheduled datetime (YYYY-MM-DDTHH:MM, local time)").option("--repeat <interval>", "New repeat interval, e.g. 1day, 2hour").option("--clear_repeat", "Convert a repeating event into a one-off").option("--repeat_stop_date <date>", "New stop date (YYYY-MM-DD, local time)").option("--clear_repeat_stop_date", "Remove the repeat stop date").option("--json", "Output as JSON").action(async (opts, command) => {
+    if (opts.description && opts.clear_description) {
+      console.error("Error: --description and --clear_description are mutually exclusive");
+      process.exit(1);
+    }
+    if (opts.repeat && opts.clear_repeat) {
+      console.error("Error: --repeat and --clear_repeat are mutually exclusive");
+      process.exit(1);
+    }
+    if (opts.repeat_stop_date && opts.clear_repeat_stop_date) {
+      console.error("Error: --repeat_stop_date and --clear_repeat_stop_date are mutually exclusive");
+      process.exit(1);
+    }
+    const body = {};
+    if (opts.event_title)
+      body.title = opts.event_title;
+    if (opts.description)
+      body.description = opts.description;
+    if (opts.clear_description)
+      body.description = null;
+    if (opts.datetime) {
+      try {
+        body.scheduled_at = parseLocalDatetime(opts.datetime);
+      } catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+      }
+    }
+    if (opts.repeat)
+      body.repeat_interval = opts.repeat;
+    if (opts.clear_repeat)
+      body.repeat_interval = null;
+    if (opts.repeat_stop_date) {
+      if (!/^\d{4}-\d{2}-\d{2}$/.test(opts.repeat_stop_date)) {
+        console.error("Error: --repeat_stop_date must be YYYY-MM-DD");
+        process.exit(1);
+      }
+      body.repeat_stop_date = opts.repeat_stop_date;
+    }
+    if (opts.clear_repeat_stop_date)
+      body.repeat_stop_date = null;
+    if (Object.keys(body).length === 0) {
+      console.error("Error: no fields to update — pass at least one of --event_title, --description, --clear_description, --datetime, --repeat, --clear_repeat, --repeat_stop_date, --clear_repeat_stop_date");
+      process.exit(1);
+    }
+    const { serverUrl, token, workspaceId } = resolveClientOpts2(command, opts.agent_id);
+    const client = new APIClient(serverUrl, token, workspaceId);
+    try {
+      const updated = await client.patchJSON(`/api/calendar/${opts.event_id}`, body);
+      if (updated.agent_id !== opts.agent_id) {
+        console.error(`Error: event ${updated.id} does not belong to agent ${opts.agent_id}`);
+        process.exit(1);
+      }
+      if (opts.json) {
+        printJSON(updated);
+        return;
+      }
+      printEventDetail(updated);
+    } catch (err) {
+      console.error(`Error: ${err instanceof Error ? err.message : err}`);
+      process.exit(1);
+    }
+  });
+  cmd.command("delete").description("Delete a calendar event").requiredOption("--agent_id <id>", "Agent ID").requiredOption("--event_id <id>", "Event ID").action(async (opts, command) => {
+    const { serverUrl, token, workspaceId } = resolveClientOpts2(command, opts.agent_id);
+    const client = new APIClient(serverUrl, token, workspaceId);
+    try {
+      await client.deleteJSON(`/api/calendar/${opts.event_id}`);
+      console.log(`Deleted ${opts.event_id}`);
+    } catch (err) {
+      console.error(`Error: ${err instanceof Error ? err.message : err}`);
+      process.exit(1);
+    }
+  });
+  return cmd;
+}
+
+// commands/version.ts
+import { Command as Command7 } from "commander";
 
 // lib/version.ts
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync4 } from "fs";
 import { join as join5, dirname as dirname4 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function getCurrentVersion() {
@@ -16380,7 +16760,7 @@ function getCurrentVersion() {
   ];
   for (const candidate of candidates) {
     try {
-      const pkg = JSON.parse(readFileSync3(candidate, "utf-8"));
+      const pkg = JSON.parse(readFileSync4(candidate, "utf-8"));
       if (typeof pkg.version === "string")
         return pkg.version;
     } catch {}
@@ -16390,19 +16770,20 @@ function getCurrentVersion() {
 
 // commands/version.ts
 function versionCommand() {
-  const cmd = new Command6("version").description("Show CLI version").action(() => {
+  const cmd = new Command7("version").description("Show CLI version").action(() => {
     console.log(`alook version ${getCurrentVersion()}`);
   });
   return cmd;
 }
 
 // src/index.ts
-var program = new Command7;
+var program = new Command8;
 program.name("alook").description("Alook CLI").option("--server <url>", "Server URL").option("--profile <name>", "Profile name");
 program.addCommand(registerCommand());
 program.addCommand(statusCommand());
 program.addCommand(daemonCommand());
 program.addCommand(emailCommand());
+program.addCommand(calendarCommand());
 program.addCommand(configCommand());
 program.addCommand(versionCommand());
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alook/cli",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "Alook CLI — register and run always-on AI coding agents.",
   "license": "Apache-2.0",
   "homepage": "https://github.com/alookai/alook#readme",