teamcopilot 0.3.6 → 0.4.1

package/dist/utils/chat-session.js

@@ -1,12 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSessionStatusTypeForSession = getSessionStatusTypeForSession;
+exports.sessionHasPendingInputForLatestAssistantMessage = sessionHasPendingInputForLatestAssistantMessage;
 exports.normalizeStaleRunningTools = normalizeStaleRunningTools;
 const assert_1 = require("./assert");
 function getSessionStatusTypeForSession(statusMap, sessionId) {
     const status = statusMap[sessionId];
     return status ? status.type : 'idle';
 }
+function sessionHasPendingInputForLatestAssistantMessage(args) {
+    if (args.latestAssistantMessageId === null) {
+        return false;
+    }
+    return (args.pendingQuestions.some((question) => question.sessionID === args.opencodeSessionId
+        && question.tool?.messageID === args.latestAssistantMessageId)
+        || args.pendingPermissions.some((permission) => permission.sessionID === args.opencodeSessionId
+            && permission.tool?.messageID === args.latestAssistantMessageId)
+        || args.customPendingPermissions.some((permission) => permission.opencode_session_id === args.opencodeSessionId
+            && permission.message_id === args.latestAssistantMessageId));
+}
 function normalizeStaleRunningTools(messages, sessionStatusType) {
     const isSessionBusy = sessionStatusType === 'busy' || sessionStatusType === 'retry';
     if (isSessionBusy) {

package/dist/utils/index.js

@@ -3,11 +3,38 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.reconcileRunningCronsAndWorkflowRunsOnStartup = reconcileRunningCronsAndWorkflowRunsOnStartup;
 exports.apiHandler = apiHandler;
 const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
 const client_1 = __importDefault(require("../prisma/client"));
 const assert_1 = require("./assert");
 const jwt_secret_1 = require("./jwt-secret");
+function nowMs() {
+    return BigInt(Date.now());
+}
+async function reconcileRunningCronsAndWorkflowRunsOnStartup() {
+    const completedAt = nowMs();
+    const workflowError = "Workflow run was interrupted because TeamCopilot restarted.";
+    await client_1.default.workflow_runs.updateMany({
+        where: { status: "running" },
+        data: {
+            status: "failed",
+            completed_at: completedAt,
+            error_message: workflowError,
+        },
+    });
+    await client_1.default.cronjob_runs.updateMany({
+        where: {
+            status: "running",
+            cronjob: { target_type: "workflow" },
+        },
+        data: {
+            status: "failed",
+            completed_at: completedAt,
+            error_message: "Workflow cronjob run was interrupted because TeamCopilot restarted.",
+        },
+    });
+}
 function apiHandler(handler, requireAuth) {
     return async (req, res, next) => {
         try {

package/dist/utils/workflow-interruption.js

@@ -3,13 +3,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.usesWorkflowDatabaseAbortMarker = usesWorkflowDatabaseAbortMarker;
 exports.isWorkflowSessionInterrupted = isWorkflowSessionInterrupted;
 exports.markWorkflowSessionAborted = markWorkflowSessionAborted;
 const client_1 = __importDefault(require("../prisma/client"));
 const opencode_client_1 = require("./opencode-client");
+function usesWorkflowDatabaseAbortMarker(sessionId) {
+    return sessionId.startsWith("manual-") || sessionId.startsWith("api-") || sessionId.startsWith("cronjob-");
+}
 async function isWorkflowSessionInterrupted(sessionId, workspaceDir) {
-    const usesDatabaseAbortMarker = sessionId.startsWith("manual-") || sessionId.startsWith("api-");
-    if (usesDatabaseAbortMarker) {
+    if (usesWorkflowDatabaseAbortMarker(sessionId)) {
         const aborted = await client_1.default.workflow_aborted_sessions.findUnique({
             where: { session_id: sessionId }
         });

package/dist/utils/workflow-run-validation.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertUserCanRunWorkflow = assertUserCanRunWorkflow;
+const resource_access_1 = require("./resource-access");
+const workflow_1 = require("./workflow");
+const workflow_approval_snapshot_1 = require("./workflow-approval-snapshot");
+async function assertUserCanRunWorkflow(slug, userId) {
+    await (0, workflow_1.readWorkflowManifestAndEnsurePermissions)(slug);
+    const approvalState = await (0, workflow_approval_snapshot_1.getWorkflowSnapshotApprovalState)(slug);
+    if (!approvalState.is_current_code_approved) {
+        throw {
+            status: 403,
+            message: "Workflow is not approved for the current code version"
+        };
+    }
+    const permissionSummary = await (0, resource_access_1.getResourceAccessSummary)("workflow", slug, userId);
+    if (!permissionSummary.can_edit) {
+        throw {
+            status: 403,
+            message: permissionSummary.is_locked_due_to_missing_users
+                ? "Workflow cannot be run because no allowed users remain"
+                : "You do not have permission to run this workflow. Please contact the workflow owner to request permission."
+        };
+    }
+}

package/dist/utils/workspace-sync.js

@@ -17,6 +17,7 @@ const util_1 = require("util");
 const crypto_1 = __importDefault(require("crypto"));
 const assert_1 = require("./assert");
 const runtime_paths_1 = require("./runtime-paths");
+const client_1 = require("../../prisma/generated/client");
 const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
 const WORKSPACE_DB_DIRECTORY = ".sqlite";
 const WORKSPACE_DB_FILENAME = "data.db";
@@ -51,6 +52,21 @@ function workspaceDatabaseExists() {
 function ensureWorkspaceDatabaseDirectory() {
     fs_1.default.mkdirSync(path_1.default.dirname(getWorkspaceDatabasePath()), { recursive: true });
 }
+async function repairWorkspaceCronjobRunUniquenessIndex(workspaceDatabaseUrl) {
+    const prisma = new client_1.PrismaClient({
+        datasourceUrl: workspaceDatabaseUrl,
+    });
+    try {
+        await prisma.$executeRawUnsafe(`
+            CREATE UNIQUE INDEX IF NOT EXISTS "cronjob_runs_one_running_per_cronjob"
+            ON "cronjob_runs"("cronjob_id")
+            WHERE "status" = 'running';
+        `);
+    }
+    finally {
+        await prisma.$disconnect();
+    }
+}
 function normalizeRelativePath(relativePath) {
     return relativePath.split(path_1.default.sep).join("/");
 }
@@ -283,4 +299,5 @@ async function ensureWorkspaceDatabase() {
             DATABASE_URL: workspaceDatabaseUrl,
         },
     });
+    await repairWorkspaceCronjobRunUniquenessIndex(workspaceDatabaseUrl);
 }

package/dist/workflows/index.js

@@ -27,6 +27,7 @@ const secrets_1 = require("../utils/secrets");
 const secret_contract_validation_1 = require("../utils/secret-contract-validation");
 const workflow_api_keys_1 = require("../utils/workflow-api-keys");
 const external_host_1 = require("../utils/external-host");
+const workflow_run_validation_1 = require("../utils/workflow-run-validation");
 const router = express_1.default.Router({ mergeParams: true });
 const uploadTmpDir = path_1.default.join(os_1.default.tmpdir(), "teamcopilot-workflow-uploads");
 fs_1.default.mkdirSync(uploadTmpDir, { recursive: true });
@@ -52,25 +53,6 @@ function isPathInside(childPath, parentPath) {
 function sanitizeFilenamePart(value) {
     return value.replace(/[^a-zA-Z0-9._-]/g, "_");
 }
-async function assertCurrentUserCanRunWorkflow(slug, userId) {
-    await (0, workflow_1.readWorkflowManifestAndEnsurePermissions)(slug);
-    const approvalState = await (0, workflow_approval_snapshot_1.getWorkflowSnapshotApprovalState)(slug);
-    if (!approvalState.is_current_code_approved) {
-        throw {
-            status: 403,
-            message: 'Workflow is not approved for the current code version'
-        };
-    }
-    const permissionSummary = await (0, resource_access_1.getResourceAccessSummary)("workflow", slug, userId);
-    if (!permissionSummary.can_edit) {
-        throw {
-            status: 403,
-            message: permissionSummary.is_locked_due_to_missing_users
-                ? 'Workflow cannot be run because no allowed users remain'
-                : 'You do not have permission to run this workflow. Please contact the workflow owner to request permission.'
-        };
-    }
-}
 async function getWorkflowEditorAccess(slug, userId) {
     const accessSummary = await (0, resource_access_1.getResourceAccessSummary)("workflow", slug, userId);
     const workflowStatus = accessSummary.is_approved ? "approved" : "pending";
@@ -285,8 +267,7 @@ router.post('/runs/:id/stop', (0, index_1.apiHandler)(async (req, res) => {
             message: 'Workflow run session not found'
         };
     }
-    const isManualSession = run.session_id.startsWith("manual-");
-    if (isManualSession) {
+    if ((0, workflow_interruption_1.usesWorkflowDatabaseAbortMarker)(run.session_id)) {
         await (0, workflow_interruption_1.markWorkflowSessionAborted)(run.session_id);
     }
     else {
@@ -309,7 +290,7 @@ router.post('/:slug/manual-run', (0, index_1.apiHandler)(async (req, res) => {
     const manualMessageId = `manual-message-${(0, crypto_1.randomUUID)()}`;
     const manualCallId = `manual-call-${(0, crypto_1.randomUUID)()}`;
     const workspaceDir = (0, workspace_sync_1.getWorkspaceDirFromEnv)();
-    await assertCurrentUserCanRunWorkflow(slug, req.userId);
+    await (0, workflow_run_validation_1.assertUserCanRunWorkflow)(slug, req.userId);
     const startedRun = await (0, workflow_runner_1.startWorkflowRunViaBackend)({
         workspaceDir,
         slug,
@@ -350,7 +331,25 @@ router.post('/execute', (0, index_1.apiHandler)(async (req, res) => {
     const messageId = body.message_id;
     const callId = body.call_id;
     const workspaceDir = (0, workspace_sync_1.getWorkspaceDirFromEnv)();
-    await assertCurrentUserCanRunWorkflow(slug, req.userId);
+    await (0, workflow_run_validation_1.assertUserCanRunWorkflow)(slug, req.userId);
+    const promptCronjobRun = await client_1.default.cronjob_runs.findFirst({
+        where: {
+            opencode_session_id: req.opencode_session_id,
+            status: "running",
+            cronjob: { target_type: "prompt" },
+        },
+        select: {
+            cronjob: {
+                select: {
+                    prompt_allow_workflow_runs_without_permission: true,
+                },
+            },
+        },
+    });
+    const requirePermissionPrompt = promptCronjobRun
+        ? promptCronjobRun.cronjob.prompt_allow_workflow_runs_without_permission !== true
+        : true;
+    const runSource = promptCronjobRun ? "cronjob" : "user";
     const startedRun = await (0, workflow_runner_1.startWorkflowRunViaBackend)({
         workspaceDir,
         slug,
@@ -359,8 +358,8 @@ router.post('/execute', (0, index_1.apiHandler)(async (req, res) => {
         sessionId: req.opencode_session_id,
         messageId,
         callId,
-        requirePermissionPrompt: true,
-        runSource: "user",
+        requirePermissionPrompt,
+        runSource,
         secretResolutionMode: "user",
     });
     const executionId = (0, crypto_1.randomUUID)();

package/dist/workspace_files/.opencode/plugins/apply-patch-session-diff.ts

@@ -242,7 +242,7 @@ function collectTrackedPathsForTool(
     return extractTrackedPathsFromPatch(patchPayload)
   }
 
-  if (tool === "write") {
+  if (tool === "write" || tool === "edit") {
     const filepath =
       findNestedStringByKeys(outputArgs, new Set(["filepath", "filePath"])) ??
       findNestedStringByKeys(inputArgs, new Set(["filepath", "filePath"]))
@@ -318,7 +318,7 @@ export const ApplyPatchSessionDiffPlugin: Plugin = async ({ client, directory })
 
   return {
     "tool.execute.before": async (input, output) => {
-      if (!["apply_patch", "write", "bash"].includes(input.tool)) {
+      if (!["apply_patch", "write", "edit", "bash"].includes(input.tool)) {
         return
       }
 

package/dist/workspace_files/.opencode/plugins/askCronjobUser.ts

@@ -0,0 +1,106 @@
+import { type Plugin, tool } from "@opencode-ai/plugin"
+
+function getApiBaseUrl(): string {
+  const port = process.env.TEAMCOPILOT_PORT?.trim()
+  if (!port) {
+    throw new Error("TEAMCOPILOT_PORT must be set.")
+  }
+  return `http://localhost:${port}`
+}
+
+interface SessionLookupResponse {
+  error?: unknown
+  data?: {
+    id?: string
+    parentID?: string
+  }
+}
+
+async function readErrorMessageFromResponse(
+  response: Response,
+  fallbackMessage: string
+): Promise<string> {
+  try {
+    const text = await response.text()
+    if (!text) return fallbackMessage
+    try {
+      const parsed: unknown = JSON.parse(text)
+      if (parsed && typeof parsed === "object" && "message" in parsed) {
+        const msg = (parsed as { message?: unknown }).message
+        if (typeof msg === "string" && msg.trim().length > 0) return msg
+      }
+    } catch {
+      // fall back to text
+    }
+    return text.trim().length > 0 ? text : fallbackMessage
+  } catch {
+    return fallbackMessage
+  }
+}
+
+export const AskCronjobUserPlugin: Plugin = async ({ client }) => {
+  async function resolveRootSessionID(sessionID: string): Promise<string> {
+    let currentSessionID = sessionID
+
+    while (true) {
+      const response = (await client.session.get({
+        path: {
+          id: currentSessionID,
+        },
+      })) as SessionLookupResponse
+      if (response.error) {
+        throw new Error(`Failed to resolve root session for ${currentSessionID}`)
+      }
+
+      const parentID = response.data?.parentID
+      if (!parentID) {
+        return currentSessionID
+      }
+
+      currentSessionID = parentID
+    }
+  }
+
+  return {
+    tool: {
+      askCronjobUser: tool({
+        description:
+          "Ask or notify the user when a TeamCopilot cronjob needs their input or attention. This reveals the hidden cronjob chat to the user and pauses cronjob auto-continue until the user explicitly resumes it.",
+        args: {
+          message: tool.schema
+            .string()
+            .describe("The message to show to the user in the cronjob chat."),
+        },
+        async execute(args, context) {
+          const { sessionID } = context
+          const authSessionID = await resolveRootSessionID(sessionID)
+          const message = args.message?.trim()
+          if (!message) {
+            throw new Error("message is required")
+          }
+
+          const response = await fetch(`${getApiBaseUrl()}/api/cronjobs/runs/ask-user-current`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `Bearer ${authSessionID}`,
+            },
+            body: JSON.stringify({ message }),
+          })
+
+          if (!response.ok) {
+            const errorMessage = await readErrorMessageFromResponse(
+              response,
+              `Failed to ask cronjob user (HTTP ${response.status})`
+            )
+            throw new Error(errorMessage)
+          }
+
+          return JSON.stringify({ success: true, message })
+        },
+      }),
+    },
+  }
+}
+
+export default AskCronjobUserPlugin

package/dist/workspace_files/.opencode/plugins/manageCronjobTodos.ts

@@ -0,0 +1,190 @@
+import { type Plugin, tool } from "@opencode-ai/plugin"
+
+function getApiBaseUrl(): string {
+  const port = process.env.TEAMCOPILOT_PORT?.trim()
+  if (!port) {
+    throw new Error("TEAMCOPILOT_PORT must be set.")
+  }
+  return `http://localhost:${port}`
+}
+
+interface SessionLookupResponse {
+  error?: unknown
+  data?: {
+    id?: string
+    parentID?: string
+  }
+}
+
+async function readErrorMessageFromResponse(
+  response: Response,
+  fallbackMessage: string
+): Promise<string> {
+  try {
+    const text = await response.text()
+    if (!text) return fallbackMessage
+    try {
+      const parsed: unknown = JSON.parse(text)
+      if (parsed && typeof parsed === "object" && "message" in parsed) {
+        const msg = (parsed as { message?: unknown }).message
+        if (typeof msg === "string" && msg.trim().length > 0) return msg
+      }
+    } catch {
+      // fall back to text
+    }
+    return text.trim().length > 0 ? text : fallbackMessage
+  } catch {
+    return fallbackMessage
+  }
+}
+
+async function postJson(path: string, authSessionID: string, body: unknown): Promise<unknown> {
+  const response = await fetch(`${getApiBaseUrl()}${path}`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${authSessionID}`,
+    },
+    body: JSON.stringify(body),
+  })
+
+  if (!response.ok) {
+    const errorMessage = await readErrorMessageFromResponse(
+      response,
+      `Cronjob todo tool failed (HTTP ${response.status})`
+    )
+    throw new Error(errorMessage)
+  }
+
+  return response.json()
+}
+
+async function getJson(path: string, authSessionID: string): Promise<unknown> {
+  const response = await fetch(`${getApiBaseUrl()}${path}`, {
+    headers: {
+      Authorization: `Bearer ${authSessionID}`,
+    },
+  })
+
+  if (!response.ok) {
+    const errorMessage = await readErrorMessageFromResponse(
+      response,
+      `Cronjob todo tool failed (HTTP ${response.status})`
+    )
+    throw new Error(errorMessage)
+  }
+
+  return response.json()
+}
+
+export const ManageCronjobTodosPlugin: Plugin = async ({ client }) => {
+  async function resolveRootSessionID(sessionID: string): Promise<string> {
+    let currentSessionID = sessionID
+
+    while (true) {
+      const response = (await client.session.get({
+        path: {
+          id: currentSessionID,
+        },
+      })) as SessionLookupResponse
+      if (response.error) {
+        throw new Error(`Failed to resolve root session for ${currentSessionID}`)
+      }
+
+      const parentID = response.data?.parentID
+      if (!parentID) {
+        return currentSessionID
+      }
+
+      currentSessionID = parentID
+    }
+  }
+
+  return {
+    tool: {
+      addCronjobTodos: tool({
+        description:
+          "Add new todo items to the active TeamCopilot cronjob todo list. You must always pass an index and the latest todo_list_version from getCronjobTodos. Example: if the active list is [A, B, C], then addCronjobTodos({ items: [\"X\", \"Y\"], index: 1, todo_list_version: 7 }) produces [A, X, Y, B, C] when the snapshot is still version 7. If you want to insert at the start of the list, use index 0. If you want to append to the end of the active list, pass index equal to the current active todo list length. If you pass an index that is greater than the current active todo list length, or a stale todo_list_version, the tool fails and returns the current todo list so you can refresh your snapshot. To make sure that you use the right index and version, always call getCronjobTodos right before calling this tool.",
+        args: {
+          items: tool.schema
+            .array(tool.schema.string())
+            .describe("New todo items required to complete the cronjob task."),
+          index: tool.schema
+            .number()
+            .describe("Required insertion index in the active todo list."),
+          todo_list_version: tool.schema
+            .number()
+            .describe("Required current todo snapshot version from the most recent getCronjobTodos call."),
+        },
+        async execute(args, context) {
+          const { sessionID } = context
+          const authSessionID = await resolveRootSessionID(sessionID)
+          return JSON.stringify(await postJson("/api/cronjobs/runs/todos/add", authSessionID, {
+            items: args.items,
+            index: args.index,
+            todo_list_version: args.todo_list_version,
+          }))
+        },
+      }),
+      clearCronjobTodos: tool({
+        description:
+          "Remove one or more todos from the active TeamCopilot cronjob todo list. Provide todo_ids only. Todo ids are the stable references returned by the todo tools.",
+        args: {
+          todo_ids: tool.schema
+            .array(tool.schema.string())
+            .optional()
+            .describe("Todo ids to remove from the active list."),
+        },
+        async execute(args, context) {
+          const { sessionID } = context
+          const authSessionID = await resolveRootSessionID(sessionID)
+          return JSON.stringify(await postJson("/api/cronjobs/runs/todos/clear", authSessionID, args))
+        },
+      }),
+      getCurrentCronjobTodo: tool({
+        description:
+          "Get the current TeamCopilot cronjob todo item, if one is active.",
+        args: {},
+        async execute(_args, context) {
+          const { sessionID } = context
+          const authSessionID = await resolveRootSessionID(sessionID)
+          const response = await getJson("/api/cronjobs/runs/todos/not-completed", authSessionID) as { todos?: Array<{ status?: string }> }
+          const currentTodo = response.todos?.find((todo) => todo.status === "in_progress") ?? null
+          return JSON.stringify({ todo: currentTodo })
+        },
+      }),
+      getCronjobTodos: tool({
+        description:
+          "Get all active TeamCopilot cronjob todos that are not completed yet, including the current todo and any pending todos. This also returns the todo_list_version you must pass back to addCronjobTodos.",
+        args: {},
+        async execute(_args, context) {
+          const { sessionID } = context
+          const authSessionID = await resolveRootSessionID(sessionID)
+          return JSON.stringify(await getJson("/api/cronjobs/runs/todos/not-completed", authSessionID))
+        },
+      }),
+      finishCurrentCronjobTodo: tool({
+        description:
+          "Mark the current TeamCopilot cronjob todo item complete. Use this only after the current todo item is fully done, then stop and wait for TeamCopilot to give you the next todo.",
+        args: {
+          completionSummary: tool.schema
+            .string()
+            .describe("Concise completion summary for what was completed for the current todo item."),
+        },
+        async execute(args, context) {
+          const { sessionID } = context
+          const authSessionID = await resolveRootSessionID(sessionID)
+          const completionSummary = args.completionSummary?.trim()
+          if (!completionSummary) {
+            throw new Error("completionSummary is required")
+          }
+          return JSON.stringify(await postJson("/api/cronjobs/runs/todos/finish-current", authSessionID, {
+            completionSummary,
+          }))
+        },
+      }),
+    },
+  }
+}
+
+export default ManageCronjobTodosPlugin