@doist/automations-cli 1.22.1 → 1.22.3

package/dist/index.js

@@ -7,7 +7,7 @@ import {
   collectSkillStatus,
   getInstaller,
   updateAllInstalledSkills
-} from "./chunk-NB7HIIJZ.js";
+} from "./chunk-DECO7WSK.js";
 
 // ../../node_modules/ajv/dist/compile/codegen/code.js
 var require_code = __commonJS({
@@ -6899,7 +6899,7 @@ import { fileURLToPath } from "node:url";
 // package.json
 var package_default = {
   name: "@doist/automations-cli",
-  version: "1.22.1",
+  version: "1.22.3",
   description: "Command-line client for Todoist Automations",
   type: "module",
   bin: {
@@ -6933,7 +6933,7 @@ var package_default = {
     build: "node scripts/build.mjs && node scripts/refresh-skills.mjs",
     dev: "node scripts/build.mjs --watch",
     "type-check": "tsc -p tsconfig.test.json --noEmit",
-    test: "vitest run",
+    test: "vitest run && node --test '../../release/*.test.mjs'",
     check: "oxfmt src scripts --check && oxlint src scripts && npm run check:skill-sync",
     "check:fix": "oxfmt src scripts && oxlint src scripts --fix",
     "sync:skill": "node scripts/sync-skill.mjs",
@@ -6957,7 +6957,6 @@ var package_default = {
     "conventional-changelog-conventionalcommits": "9.3.1",
     esbuild: "0.28.2",
     "semantic-release": "25.0.9",
-    "semantic-release-monorepo": "8.0.2",
     typescript: "6.0.3",
     vitest: "5.0.5"
   },
@@ -34696,6 +34695,491 @@ function addWorkspaceScopeOptions(command) {
   ).option("--personal", "Act on your personal space, ignoring any pinned workspace");
 }
 
+// ../../packages/sdk/dist/esm/chat-turn/connection-requirements.js
+var CONNECTION_LOOKUP_CONCURRENCY = 4;
+function deduplicateConnectionRequirements(requirements) {
+  const seen = /* @__PURE__ */ new Set();
+  return requirements.filter((requirement) => {
+    const key = JSON.stringify([requirement.connectorId, requirement.connectionType]);
+    if (seen.has(key))
+      return false;
+    seen.add(key);
+    return true;
+  });
+}
+async function loadConnectionRequirements(connections, requirements, options) {
+  return mapWithConcurrency(deduplicateConnectionRequirements(requirements), CONNECTION_LOOKUP_CONCURRENCY, async (requirement) => {
+    const response = await connections.list({
+      connectorId: requirement.connectorId,
+      capability: requirement.connectionType,
+      status: "authorized"
+    }, options);
+    return {
+      ...requirement,
+      availableConnections: response.connections.map((connection) => ({
+        id: connection.id,
+        label: connection.accountDisplayLabel ?? connection.name ?? connection.id
+      }))
+    };
+  });
+}
+async function mapWithConcurrency(items, concurrency, map2) {
+  const results = new Array(items.length);
+  let next = 0;
+  const workers = Array.from({ length: Math.min(concurrency, items.length) }, async () => {
+    while (next < items.length) {
+      const index = next;
+      next += 1;
+      results[index] = await map2(items[index]);
+    }
+  });
+  await Promise.all(workers);
+  return results;
+}
+
+// ../../packages/sdk/dist/esm/chat-turn/connection-setup.js
+async function startConnectionSetup(connections, request2, options) {
+  const created = await connections.create({
+    connectorId: request2.connectorId,
+    capability: request2.capability,
+    ...request2.automationIds?.length ? { body: { automationIds: [...request2.automationIds] } } : {}
+  }, options);
+  return { connectionId: created.connectionId, setup: created.setup, resumed: false };
+}
+function summarizeConnectionSetup(setup) {
+  if (setup?.kind === "oauth") {
+    return { setupKind: "oauth", authorizationUrl: setup.authorizationUrl };
+  }
+  if (setup?.kind === "managed") {
+    return {
+      setupKind: "managed",
+      instructions: setup.instructions,
+      code: setup.code,
+      deepLinkUrl: setup.deepLinkUrl,
+      expiresAt: setup.expiresAt
+    };
+  }
+  return { setupKind: "none" };
+}
+function getConnectionSetupUrl(setup) {
+  if (setup?.kind === "oauth")
+    return setup.authorizationUrl;
+  if (setup?.kind === "managed")
+    return setup.deepLinkUrl;
+  return null;
+}
+
+// ../../packages/core/dist/esm/chat-tools/client-tool-result.js
+var clientToolContinuationPartSchema = external_exports.discriminatedUnion("type", [
+  toolPromptEnablePushResultSchema.omit({ input: true }).strict(),
+  toolSelectConnectionsResultSchema.omit({ input: true }).strict()
+]);
+
+// ../../packages/core/dist/esm/chat-tools/update-memory.js
+var UpdateMemoryInputSchema = external_exports.object({
+  append: external_exports.string().min(1).optional(),
+  replace: external_exports.object({
+    old: external_exports.string().min(1),
+    new: external_exports.string()
+  }).optional()
+});
+var UpdateMemoryOutputSchema = external_exports.object({
+  memory: external_exports.string().nullable(),
+  // What the memory held before this write — the chat UI's Undo restores it.
+  previousMemory: external_exports.string().nullable()
+});
+var toolUpdateMemorySchema = external_exports.object({
+  type: external_exports.literal("tool-update-memory"),
+  toolCallId: external_exports.string().min(1),
+  state: external_exports.literal("input-available"),
+  input: UpdateMemoryInputSchema
+});
+var toolUpdateMemoryResultSchema = external_exports.object({
+  type: external_exports.literal("tool-update-memory"),
+  toolCallId: external_exports.string().min(1),
+  state: external_exports.literal("output-available"),
+  input: UpdateMemoryInputSchema,
+  output: UpdateMemoryOutputSchema
+});
+
+// ../../packages/sdk/dist/esm/chat-turn/messages.js
+var persistedToolPartSchema = external_exports.object({
+  type: external_exports.string().trim().min(6).refine((type) => type.startsWith("tool-")),
+  toolCallId: external_exports.string().trim().min(1),
+  state: external_exports.enum(["input-streaming", "input-available", "output-available", "output-error"])
+}).passthrough();
+function createUserMessage(text2) {
+  return {
+    id: globalThis.crypto.randomUUID(),
+    role: "user",
+    parts: [{ type: "text", text: text2 }]
+  };
+}
+function toUiMessage(message) {
+  if (message.role !== "user" && message.role !== "assistant" && message.role !== "system") {
+    throw new Error(`Unsupported persisted chat role: ${message.role}`);
+  }
+  if (!Array.isArray(message.parts)) {
+    throw new Error(`Persisted chat message ${message.messageId} has invalid parts.`);
+  }
+  return {
+    id: message.messageId,
+    role: message.role,
+    parts: normalizePersistedMessageParts(message.parts)
+  };
+}
+function normalizePersistedMessageParts(parts) {
+  return parts.filter((part) => isTextPart(part) || isStepStartPart(part) || isReasoningPart(part) || persistedToolPartSchema.safeParse(part).success);
+}
+function isTextPart(part) {
+  if (typeof part !== "object" || part === null) {
+    return false;
+  }
+  const candidate = part;
+  return candidate.type === "text" && typeof candidate.text === "string";
+}
+function isStepStartPart(part) {
+  if (typeof part !== "object" || part === null) {
+    return false;
+  }
+  return part.type === "step-start";
+}
+function isReasoningPart(part) {
+  if (typeof part !== "object" || part === null) {
+    return false;
+  }
+  const candidate = part;
+  return candidate.type === "reasoning" && typeof candidate.text === "string" && (candidate.state === void 0 || candidate.state === "streaming" || candidate.state === "done");
+}
+function getVisibleText(message) {
+  return message.parts.filter((part) => part.type === "text").map((part) => part.text).join("");
+}
+function getPendingClientAction(message) {
+  for (let index = message.parts.length - 1; index >= 0; index -= 1) {
+    const part = message.parts[index];
+    if (isSelectConnections(part)) {
+      return {
+        kind: "select_connections",
+        message,
+        toolCallId: part.toolCallId,
+        draftId: part.input.draftId,
+        connections: part.input.connections
+      };
+    }
+    if (isPromptEnablePush(part)) {
+      return {
+        kind: "enable_push",
+        message,
+        toolCallId: part.toolCallId,
+        draftId: part.input.draftId
+      };
+    }
+  }
+  return null;
+}
+function getPendingActionFromMessages(messages) {
+  const latestMessage = messages.at(-1);
+  if (!latestMessage || latestMessage.role !== "assistant")
+    return null;
+  return getPendingClientAction(toUiMessage(latestMessage));
+}
+function getPublishedAutomationId(message) {
+  for (let index = message.parts.length - 1; index >= 0; index -= 1) {
+    const part = message.parts[index];
+    if (isPublishDraftResult(part) && part.output.success) {
+      return part.output.automationId;
+    }
+  }
+  return void 0;
+}
+function createEnablePushContinuation(action, output2) {
+  return {
+    id: action.message.id,
+    role: "assistant",
+    parts: [
+      {
+        type: "tool-prompt-enable-push-notifications",
+        toolCallId: action.toolCallId,
+        state: "output-available",
+        output: output2
+      }
+    ]
+  };
+}
+function createSelectConnectionsContinuation(action, output2) {
+  return {
+    id: action.message.id,
+    role: "assistant",
+    parts: [
+      {
+        type: "tool-select-connections",
+        toolCallId: action.toolCallId,
+        state: "output-available",
+        output: output2
+      }
+    ]
+  };
+}
+
+// ../../packages/sdk/dist/esm/chat-turn/types.js
+var ChatTurnInputError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "ChatTurnInputError";
+    this.code = code;
+  }
+};
+
+// ../../packages/sdk/dist/esm/chat-turn/run-conversation-turn.js
+async function runConversationTurn(options) {
+  const { api, transport, conversationId, signal } = options;
+  const workspaceId = options.workspaceId ?? null;
+  const requestOptions = { signal };
+  const pending = await readPendingAction(options);
+  let nextMessage;
+  if (pending?.kind === "enable_push") {
+    if ("message" in options.input || options.input.selections.length > 0) {
+      throw new ChatTurnInputError("awaiting_push", "The conversation is waiting for the push notification prompt to be answered.");
+    }
+    nextMessage = await answerEnablePush(options, pending);
+  } else if ("message" in options.input) {
+    if (pending?.kind === "select_connections") {
+      throw new ChatTurnInputError("awaiting_selection", "The conversation is waiting for connection selection.");
+    }
+    nextMessage = createUserMessage(options.input.message);
+  } else {
+    const selections = options.input.selections;
+    if (pending?.kind !== "select_connections") {
+      throw new ChatTurnInputError(selections.length > 0 ? "not_awaiting_selection" : "input_required", selections.length > 0 ? "The conversation is not waiting for connection selection." : "A message is required to continue.");
+    }
+    const resolution = await resolveSelectConnections(options, pending, selections);
+    if (resolution.kind === "required") {
+      return actionRequired(conversationId, getVisibleText(pending.message), resolution.pendingAction);
+    }
+    nextMessage = resolution.continuation;
+  }
+  while (true) {
+    const response = await transport.streamTurn({
+      conversationId,
+      workspaceId,
+      message: nextMessage,
+      signal,
+      onText: options.onText,
+      onToolActivity: options.onToolActivity
+    });
+    const assistantText = getVisibleText(response);
+    const automationId = getPublishedAutomationId(response);
+    if (automationId) {
+      options.onPublished?.(automationId);
+      const archive = await archiveConversation(api, conversationId, requestOptions);
+      return {
+        conversationId,
+        outcome: "published",
+        assistantText,
+        automationId,
+        ...archive
+      };
+    }
+    const responseAction = getPendingClientAction(response);
+    if (responseAction?.kind === "select_connections") {
+      const resolution = await resolveSelectConnections(options, responseAction, []);
+      if (resolution.kind === "resolved") {
+        nextMessage = resolution.continuation;
+        continue;
+      }
+      return actionRequired(conversationId, assistantText, resolution.pendingAction);
+    }
+    if (responseAction?.kind === "enable_push") {
+      return actionRequired(conversationId, assistantText, {
+        kind: "enable_push",
+        toolCallId: responseAction.toolCallId,
+        draftId: responseAction.draftId
+      });
+    }
+    return { conversationId, outcome: "awaiting_input", assistantText };
+  }
+}
+async function answerEnablePush(options, action) {
+  const { subscriptions } = await options.api.notifications.push.list({
+    signal: options.signal
+  });
+  const deviceCount = subscriptions.length;
+  return createEnablePushContinuation(action, {
+    enabled: deviceCount > 0,
+    deviceCount,
+    message: deviceCount > 0 ? `Push notifications are enabled on ${deviceCount} device${deviceCount === 1 ? "" : "s"}.` : "The user has not enabled push notifications."
+  });
+}
+async function readPendingAction(options) {
+  if (options.pendingAction !== void 0)
+    return options.pendingAction;
+  const messages = await options.api.chat.getMessages(options.conversationId, {
+    signal: options.signal
+  });
+  return getPendingActionFromMessages(messages);
+}
+function actionRequired(conversationId, assistantText, pendingAction) {
+  return { conversationId, outcome: "action_required", assistantText, pendingAction };
+}
+async function archiveConversation(api, conversationId, requestOptions) {
+  try {
+    const conversation = await api.chat.updateConversation(conversationId, { isArchived: true }, requestOptions);
+    if (!conversation.isArchived) {
+      throw new Error("The Automations API returned an active conversation.");
+    }
+    return { conversationArchived: true };
+  } catch (error62) {
+    return {
+      conversationArchived: false,
+      conversationArchiveError: error62 instanceof Error ? error62.message : String(error62)
+    };
+  }
+}
+async function resolveSelectConnections(options, action, selections) {
+  const { api, signal } = options;
+  const requestOptions = { signal };
+  const requirements = await loadConnectionRequirements(api.connections, action.connections, requestOptions);
+  assertSelectionsUnambiguous(requirements, selections);
+  const resolved = [];
+  for (const requirement of requirements) {
+    const explicit = selections.find((selection) => selection.connectorId === requirement.connectorId && (!selection.connectionType || selection.connectionType === requirement.connectionType));
+    let connectionId = explicit?.connectionId;
+    let setup;
+    if (connectionId) {
+      const exists = requirement.availableConnections.some((connection) => connection.id === connectionId);
+      if (!exists) {
+        throw new ChatTurnInputError("unknown_connection", `Connection ${connectionId} is not an authorized ${requirement.serviceName} connection.`);
+      }
+    } else if (requirement.availableConnections.length === 1) {
+      connectionId = requirement.availableConnections[0]?.id;
+    } else if (requirement.availableConnections.length > 1) {
+      connectionId = await options.chooseConnection?.(requirement);
+    } else if (options.authorizeConnection) {
+      connectionId = await options.authorizeConnection(requirement);
+    } else {
+      setup = await startConnectionSetup(api.connections, { connectorId: requirement.connectorId, capability: requirement.connectionType }, requestOptions);
+    }
+    if (!connectionId) {
+      return {
+        kind: "required",
+        pendingAction: {
+          kind: "select_connections",
+          toolCallId: action.toolCallId,
+          draftId: action.draftId,
+          requirements: requirements.map((item) => item === requirement && setup ? { ...item, setup } : item)
+        }
+      };
+    }
+    resolved.push({ requirement, connectionId });
+  }
+  const output2 = [];
+  for (const item of resolved) {
+    const body = {
+      connectorId: item.requirement.connectorId,
+      connectionType: item.requirement.connectionType,
+      connectionId: item.connectionId
+    };
+    const workspaceId = options.workspaceId ?? null;
+    if (workspaceId === null) {
+      await api.automationDraftConnections.upsert(action.draftId, body, requestOptions);
+    } else {
+      await api.workspaceAutomationDraftConnections.upsert(workspaceId, action.draftId, body, requestOptions);
+    }
+    output2.push({ type: "success", ...body });
+  }
+  return { kind: "resolved", continuation: createSelectConnectionsContinuation(action, output2) };
+}
+function assertSelectionsUnambiguous(requirements, selections) {
+  for (const selection of selections) {
+    if (selection.connectionType)
+      continue;
+    const matchingTypes = new Set(requirements.filter((requirement) => requirement.connectorId === selection.connectorId).map((requirement) => requirement.connectionType));
+    if (matchingTypes.size > 1) {
+      throw new ChatTurnInputError("ambiguous_selection", `Connection selection for ${selection.connectorId} is ambiguous. Specify ${selection.connectorId}:mcp or ${selection.connectorId}:trigger.`);
+    }
+  }
+}
+
+// ../../packages/sdk/dist/esm/chat-turn/transport.js
+import { DefaultChatTransport, readUIMessageStream } from "ai";
+var ChatTurnTransport = class {
+  transport;
+  constructor({ token, baseUrl, headers, fetch: fetch2 }) {
+    const apiRoot = `${baseUrl.replace(/\/+$/, "")}/v1`;
+    this.transport = new DefaultChatTransport({
+      api: `${apiRoot}/chat`,
+      headers: {
+        Authorization: `Bearer ${token}`,
+        ...headers
+      },
+      credentials: "include",
+      fetch: fetch2,
+      prepareSendMessagesRequest({ messages, body, api }) {
+        const { workspaceId, ...rest } = body ?? {};
+        return {
+          api: workspaceId ? `${apiRoot}/workspaces/${encodeURIComponent(workspaceId)}/chat` : api,
+          body: {
+            ...rest,
+            message: messages.at(-1)
+          }
+        };
+      }
+    });
+  }
+  /** Streams one server turn, reporting incremental text and deduplicated tool state changes. */
+  async streamTurn({ conversationId, workspaceId = null, message, signal, onText, onToolActivity }) {
+    const stream = await this.transport.sendMessages({
+      trigger: "submit-message",
+      chatId: conversationId,
+      messageId: void 0,
+      messages: [message],
+      abortSignal: signal,
+      body: { conversationId, workspaceId }
+    });
+    let finalMessage;
+    let emittedText = "";
+    const emittedToolStates = /* @__PURE__ */ new Set();
+    for await (const currentMessage of readUIMessageStream({
+      stream,
+      terminateOnError: true
+    })) {
+      finalMessage = currentMessage;
+      const visibleText = getVisibleText(currentMessage);
+      if (visibleText.startsWith(emittedText)) {
+        const delta = visibleText.slice(emittedText.length);
+        if (delta)
+          onText?.(delta);
+        emittedText = visibleText;
+      }
+      for (const part of currentMessage.parts) {
+        const activity = toToolActivity(part);
+        if (!activity)
+          continue;
+        const key = `${activity.toolCallId}:${activity.state}`;
+        if (emittedToolStates.has(key))
+          continue;
+        emittedToolStates.add(key);
+        onToolActivity?.(activity);
+      }
+    }
+    if (!finalMessage) {
+      throw new Error("The Automations chat returned an empty response.");
+    }
+    return finalMessage;
+  }
+};
+function toToolActivity(part) {
+  if (!part.type.startsWith("tool-") || !("toolCallId" in part) || !("state" in part)) {
+    return null;
+  }
+  return {
+    tool: part.type.slice("tool-".length),
+    toolCallId: String(part.toolCallId),
+    state: String(part.state)
+  };
+}
+
 // src/commands/read/format.ts
 function formatAutomationList(page) {
   if (page.data.length === 0) return "No automations found.";
@@ -34864,9 +35348,6 @@ function getMessageSummary(message) {
   const partTypes = message.parts.filter(isRecord2).map((part) => typeof part.type === "string" ? part.type : "unknown");
   return partTypes.length > 0 ? `[${partTypes.join(", ")}]` : "(no visible text)";
 }
-function isTextPart(value) {
-  return isRecord2(value) && value.type === "text" && typeof value.text === "string";
-}
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -35245,463 +35726,6 @@ function collectOption(value, previous) {
   return [...previous, value];
 }
 
-// ../../packages/sdk/dist/esm/chat-turn/connection-requirements.js
-var CONNECTION_LOOKUP_CONCURRENCY = 4;
-function deduplicateConnectionRequirements(requirements) {
-  const seen = /* @__PURE__ */ new Set();
-  return requirements.filter((requirement) => {
-    const key = JSON.stringify([requirement.connectorId, requirement.connectionType]);
-    if (seen.has(key))
-      return false;
-    seen.add(key);
-    return true;
-  });
-}
-async function loadConnectionRequirements(connections, requirements, options) {
-  return mapWithConcurrency(deduplicateConnectionRequirements(requirements), CONNECTION_LOOKUP_CONCURRENCY, async (requirement) => {
-    const response = await connections.list({
-      connectorId: requirement.connectorId,
-      capability: requirement.connectionType,
-      status: "authorized"
-    }, options);
-    return {
-      ...requirement,
-      availableConnections: response.connections.map((connection) => ({
-        id: connection.id,
-        label: connection.accountDisplayLabel ?? connection.name ?? connection.id
-      }))
-    };
-  });
-}
-async function mapWithConcurrency(items, concurrency, map2) {
-  const results = new Array(items.length);
-  let next = 0;
-  const workers = Array.from({ length: Math.min(concurrency, items.length) }, async () => {
-    while (next < items.length) {
-      const index = next;
-      next += 1;
-      results[index] = await map2(items[index]);
-    }
-  });
-  await Promise.all(workers);
-  return results;
-}
-
-// ../../packages/sdk/dist/esm/chat-turn/connection-setup.js
-async function startConnectionSetup(connections, request2, options) {
-  const created = await connections.create({
-    connectorId: request2.connectorId,
-    capability: request2.capability,
-    ...request2.automationIds?.length ? { body: { automationIds: [...request2.automationIds] } } : {}
-  }, options);
-  return { connectionId: created.connectionId, setup: created.setup, resumed: false };
-}
-function summarizeConnectionSetup(setup) {
-  if (setup?.kind === "oauth") {
-    return { setupKind: "oauth", authorizationUrl: setup.authorizationUrl };
-  }
-  if (setup?.kind === "managed") {
-    return {
-      setupKind: "managed",
-      instructions: setup.instructions,
-      code: setup.code,
-      deepLinkUrl: setup.deepLinkUrl,
-      expiresAt: setup.expiresAt
-    };
-  }
-  return { setupKind: "none" };
-}
-function getConnectionSetupUrl(setup) {
-  if (setup?.kind === "oauth")
-    return setup.authorizationUrl;
-  if (setup?.kind === "managed")
-    return setup.deepLinkUrl;
-  return null;
-}
-
-// ../../packages/core/dist/esm/chat-tools/client-tool-result.js
-var clientToolContinuationPartSchema = external_exports.discriminatedUnion("type", [
-  toolPromptEnablePushResultSchema.omit({ input: true }).strict(),
-  toolSelectConnectionsResultSchema.omit({ input: true }).strict()
-]);
-
-// ../../packages/core/dist/esm/chat-tools/update-memory.js
-var UpdateMemoryInputSchema = external_exports.object({
-  append: external_exports.string().min(1).optional(),
-  replace: external_exports.object({
-    old: external_exports.string().min(1),
-    new: external_exports.string()
-  }).optional()
-});
-var UpdateMemoryOutputSchema = external_exports.object({
-  memory: external_exports.string().nullable(),
-  // What the memory held before this write — the chat UI's Undo restores it.
-  previousMemory: external_exports.string().nullable()
-});
-var toolUpdateMemorySchema = external_exports.object({
-  type: external_exports.literal("tool-update-memory"),
-  toolCallId: external_exports.string().min(1),
-  state: external_exports.literal("input-available"),
-  input: UpdateMemoryInputSchema
-});
-var toolUpdateMemoryResultSchema = external_exports.object({
-  type: external_exports.literal("tool-update-memory"),
-  toolCallId: external_exports.string().min(1),
-  state: external_exports.literal("output-available"),
-  input: UpdateMemoryInputSchema,
-  output: UpdateMemoryOutputSchema
-});
-
-// ../../packages/sdk/dist/esm/chat-turn/messages.js
-function createUserMessage(text2) {
-  return {
-    id: globalThis.crypto.randomUUID(),
-    role: "user",
-    parts: [{ type: "text", text: text2 }]
-  };
-}
-function toUiMessage(message) {
-  if (message.role !== "user" && message.role !== "assistant" && message.role !== "system") {
-    throw new Error(`Unsupported persisted chat role: ${message.role}`);
-  }
-  if (!Array.isArray(message.parts)) {
-    throw new Error(`Persisted chat message ${message.messageId} has invalid parts.`);
-  }
-  return {
-    id: message.messageId,
-    role: message.role,
-    parts: message.parts
-  };
-}
-function getVisibleText(message) {
-  return message.parts.filter((part) => part.type === "text").map((part) => part.text).join("");
-}
-function getPendingClientAction(message) {
-  for (let index = message.parts.length - 1; index >= 0; index -= 1) {
-    const part = message.parts[index];
-    if (isSelectConnections(part)) {
-      return {
-        kind: "select_connections",
-        message,
-        toolCallId: part.toolCallId,
-        draftId: part.input.draftId,
-        connections: part.input.connections
-      };
-    }
-    if (isPromptEnablePush(part)) {
-      return {
-        kind: "enable_push",
-        message,
-        toolCallId: part.toolCallId,
-        draftId: part.input.draftId
-      };
-    }
-  }
-  return null;
-}
-function getPendingActionFromMessages(messages) {
-  const latestMessage = messages.at(-1);
-  if (!latestMessage || latestMessage.role !== "assistant")
-    return null;
-  return getPendingClientAction(toUiMessage(latestMessage));
-}
-function getPublishedAutomationId(message) {
-  for (let index = message.parts.length - 1; index >= 0; index -= 1) {
-    const part = message.parts[index];
-    if (isPublishDraftResult(part) && part.output.success) {
-      return part.output.automationId;
-    }
-  }
-  return void 0;
-}
-function createEnablePushContinuation(action, output2) {
-  return {
-    id: action.message.id,
-    role: "assistant",
-    parts: [
-      {
-        type: "tool-prompt-enable-push-notifications",
-        toolCallId: action.toolCallId,
-        state: "output-available",
-        output: output2
-      }
-    ]
-  };
-}
-function createSelectConnectionsContinuation(action, output2) {
-  return {
-    id: action.message.id,
-    role: "assistant",
-    parts: [
-      {
-        type: "tool-select-connections",
-        toolCallId: action.toolCallId,
-        state: "output-available",
-        output: output2
-      }
-    ]
-  };
-}
-
-// ../../packages/sdk/dist/esm/chat-turn/types.js
-var ChatTurnInputError = class extends Error {
-  code;
-  constructor(code, message) {
-    super(message);
-    this.name = "ChatTurnInputError";
-    this.code = code;
-  }
-};
-
-// ../../packages/sdk/dist/esm/chat-turn/run-conversation-turn.js
-async function runConversationTurn(options) {
-  const { api, transport, conversationId, signal } = options;
-  const workspaceId = options.workspaceId ?? null;
-  const requestOptions = { signal };
-  const pending = await readPendingAction(options);
-  let nextMessage;
-  if (pending?.kind === "enable_push") {
-    if ("message" in options.input || options.input.selections.length > 0) {
-      throw new ChatTurnInputError("awaiting_push", "The conversation is waiting for the push notification prompt to be answered.");
-    }
-    nextMessage = await answerEnablePush(options, pending);
-  } else if ("message" in options.input) {
-    if (pending?.kind === "select_connections") {
-      throw new ChatTurnInputError("awaiting_selection", "The conversation is waiting for connection selection.");
-    }
-    nextMessage = createUserMessage(options.input.message);
-  } else {
-    const selections = options.input.selections;
-    if (pending?.kind !== "select_connections") {
-      throw new ChatTurnInputError(selections.length > 0 ? "not_awaiting_selection" : "input_required", selections.length > 0 ? "The conversation is not waiting for connection selection." : "A message is required to continue.");
-    }
-    const resolution = await resolveSelectConnections(options, pending, selections);
-    if (resolution.kind === "required") {
-      return actionRequired(conversationId, getVisibleText(pending.message), resolution.pendingAction);
-    }
-    nextMessage = resolution.continuation;
-  }
-  while (true) {
-    const response = await transport.streamTurn({
-      conversationId,
-      workspaceId,
-      message: nextMessage,
-      signal,
-      onText: options.onText,
-      onToolActivity: options.onToolActivity
-    });
-    const assistantText = getVisibleText(response);
-    const automationId = getPublishedAutomationId(response);
-    if (automationId) {
-      options.onPublished?.(automationId);
-      const archive = await archiveConversation(api, conversationId, requestOptions);
-      return {
-        conversationId,
-        outcome: "published",
-        assistantText,
-        automationId,
-        ...archive
-      };
-    }
-    const responseAction = getPendingClientAction(response);
-    if (responseAction?.kind === "select_connections") {
-      const resolution = await resolveSelectConnections(options, responseAction, []);
-      if (resolution.kind === "resolved") {
-        nextMessage = resolution.continuation;
-        continue;
-      }
-      return actionRequired(conversationId, assistantText, resolution.pendingAction);
-    }
-    if (responseAction?.kind === "enable_push") {
-      return actionRequired(conversationId, assistantText, {
-        kind: "enable_push",
-        toolCallId: responseAction.toolCallId,
-        draftId: responseAction.draftId
-      });
-    }
-    return { conversationId, outcome: "awaiting_input", assistantText };
-  }
-}
-async function answerEnablePush(options, action) {
-  const { subscriptions } = await options.api.notifications.push.list({
-    signal: options.signal
-  });
-  const deviceCount = subscriptions.length;
-  return createEnablePushContinuation(action, {
-    enabled: deviceCount > 0,
-    deviceCount,
-    message: deviceCount > 0 ? `Push notifications are enabled on ${deviceCount} device${deviceCount === 1 ? "" : "s"}.` : "The user has not enabled push notifications."
-  });
-}
-async function readPendingAction(options) {
-  if (options.pendingAction !== void 0)
-    return options.pendingAction;
-  const messages = await options.api.chat.getMessages(options.conversationId, {
-    signal: options.signal
-  });
-  return getPendingActionFromMessages(messages);
-}
-function actionRequired(conversationId, assistantText, pendingAction) {
-  return { conversationId, outcome: "action_required", assistantText, pendingAction };
-}
-async function archiveConversation(api, conversationId, requestOptions) {
-  try {
-    const conversation = await api.chat.updateConversation(conversationId, { isArchived: true }, requestOptions);
-    if (!conversation.isArchived) {
-      throw new Error("The Automations API returned an active conversation.");
-    }
-    return { conversationArchived: true };
-  } catch (error62) {
-    return {
-      conversationArchived: false,
-      conversationArchiveError: error62 instanceof Error ? error62.message : String(error62)
-    };
-  }
-}
-async function resolveSelectConnections(options, action, selections) {
-  const { api, signal } = options;
-  const requestOptions = { signal };
-  const requirements = await loadConnectionRequirements(api.connections, action.connections, requestOptions);
-  assertSelectionsUnambiguous(requirements, selections);
-  const resolved = [];
-  for (const requirement of requirements) {
-    const explicit = selections.find((selection) => selection.connectorId === requirement.connectorId && (!selection.connectionType || selection.connectionType === requirement.connectionType));
-    let connectionId = explicit?.connectionId;
-    let setup;
-    if (connectionId) {
-      const exists = requirement.availableConnections.some((connection) => connection.id === connectionId);
-      if (!exists) {
-        throw new ChatTurnInputError("unknown_connection", `Connection ${connectionId} is not an authorized ${requirement.serviceName} connection.`);
-      }
-    } else if (requirement.availableConnections.length === 1) {
-      connectionId = requirement.availableConnections[0]?.id;
-    } else if (requirement.availableConnections.length > 1) {
-      connectionId = await options.chooseConnection?.(requirement);
-    } else if (options.authorizeConnection) {
-      connectionId = await options.authorizeConnection(requirement);
-    } else {
-      setup = await startConnectionSetup(api.connections, { connectorId: requirement.connectorId, capability: requirement.connectionType }, requestOptions);
-    }
-    if (!connectionId) {
-      return {
-        kind: "required",
-        pendingAction: {
-          kind: "select_connections",
-          toolCallId: action.toolCallId,
-          draftId: action.draftId,
-          requirements: requirements.map((item) => item === requirement && setup ? { ...item, setup } : item)
-        }
-      };
-    }
-    resolved.push({ requirement, connectionId });
-  }
-  const output2 = [];
-  for (const item of resolved) {
-    const body = {
-      connectorId: item.requirement.connectorId,
-      connectionType: item.requirement.connectionType,
-      connectionId: item.connectionId
-    };
-    const workspaceId = options.workspaceId ?? null;
-    if (workspaceId === null) {
-      await api.automationDraftConnections.upsert(action.draftId, body, requestOptions);
-    } else {
-      await api.workspaceAutomationDraftConnections.upsert(workspaceId, action.draftId, body, requestOptions);
-    }
-    output2.push({ type: "success", ...body });
-  }
-  return { kind: "resolved", continuation: createSelectConnectionsContinuation(action, output2) };
-}
-function assertSelectionsUnambiguous(requirements, selections) {
-  for (const selection of selections) {
-    if (selection.connectionType)
-      continue;
-    const matchingTypes = new Set(requirements.filter((requirement) => requirement.connectorId === selection.connectorId).map((requirement) => requirement.connectionType));
-    if (matchingTypes.size > 1) {
-      throw new ChatTurnInputError("ambiguous_selection", `Connection selection for ${selection.connectorId} is ambiguous. Specify ${selection.connectorId}:mcp or ${selection.connectorId}:trigger.`);
-    }
-  }
-}
-
-// ../../packages/sdk/dist/esm/chat-turn/transport.js
-import { DefaultChatTransport, readUIMessageStream } from "ai";
-var ChatTurnTransport = class {
-  transport;
-  constructor({ token, baseUrl, headers, fetch: fetch2 }) {
-    const apiRoot = `${baseUrl.replace(/\/+$/, "")}/v1`;
-    this.transport = new DefaultChatTransport({
-      api: `${apiRoot}/chat`,
-      headers: {
-        Authorization: `Bearer ${token}`,
-        ...headers
-      },
-      credentials: "include",
-      fetch: fetch2,
-      prepareSendMessagesRequest({ messages, body, api }) {
-        const { workspaceId, ...rest } = body ?? {};
-        return {
-          api: workspaceId ? `${apiRoot}/workspaces/${encodeURIComponent(workspaceId)}/chat` : api,
-          body: {
-            ...rest,
-            message: messages.at(-1)
-          }
-        };
-      }
-    });
-  }
-  /** Streams one server turn, reporting incremental text and deduplicated tool state changes. */
-  async streamTurn({ conversationId, workspaceId = null, message, signal, onText, onToolActivity }) {
-    const stream = await this.transport.sendMessages({
-      trigger: "submit-message",
-      chatId: conversationId,
-      messageId: void 0,
-      messages: [message],
-      abortSignal: signal,
-      body: { conversationId, workspaceId }
-    });
-    let finalMessage;
-    let emittedText = "";
-    const emittedToolStates = /* @__PURE__ */ new Set();
-    for await (const currentMessage of readUIMessageStream({
-      stream,
-      terminateOnError: true
-    })) {
-      finalMessage = currentMessage;
-      const visibleText = getVisibleText(currentMessage);
-      if (visibleText.startsWith(emittedText)) {
-        const delta = visibleText.slice(emittedText.length);
-        if (delta)
-          onText?.(delta);
-        emittedText = visibleText;
-      }
-      for (const part of currentMessage.parts) {
-        const activity = toToolActivity(part);
-        if (!activity)
-          continue;
-        const key = `${activity.toolCallId}:${activity.state}`;
-        if (emittedToolStates.has(key))
-          continue;
-        emittedToolStates.add(key);
-        onToolActivity?.(activity);
-      }
-    }
-    if (!finalMessage) {
-      throw new Error("The Automations chat returned an empty response.");
-    }
-    return finalMessage;
-  }
-};
-function toToolActivity(part) {
-  if (!part.type.startsWith("tool-") || !("toolCallId" in part) || !("state" in part)) {
-    return null;
-  }
-  return {
-    tool: part.type.slice("tool-".length),
-    toolCallId: String(part.toolCallId),
-    state: String(part.state)
-  };
-}
-
 // src/commands/chat/chat-service.ts
 import { createInterface } from "node:readline/promises";
 
@@ -38203,6 +38227,9 @@ function registerUpdateCommand(program) {
   });
 }
 
+// src/commands/workspace/index.ts
+import { CliError as CliError9 } from "@doist/cli-core";
+
 // src/commands/workspace/format.ts
 function formatWorkspaceList(workspaces) {
   if (workspaces.length === 0) {
@@ -38237,7 +38264,25 @@ function registerWorkspaceCommand(program) {
   workspace.command("list").description("List the workspaces you can use").action(async (_options, command) => {
     await runApiCommand(
       command,
-      ({ api, signal }) => api.workspaces.list({ signal }),
+      async ({ api, signal }) => {
+        try {
+          return await api.workspaces.list({ signal });
+        } catch (error62) {
+          if (!(error62 instanceof AutomationsRequestError) || error62.httpStatusCode !== 404) {
+            throw error62;
+          }
+          throw new CliError9(
+            "WORKSPACE_ACCESS_UNAVAILABLE",
+            "Workspace access is not available for this account or environment.",
+            {
+              hints: [
+                "Use your personal space, for example: tda automation list --personal",
+                "Contact support if you expect workspace access."
+              ]
+            }
+          );
+        }
+      },
       {
         human: formatWorkspaceList,
         json: summarizeWorkspaceList,