teamcopilot 0.3.6 → 0.4.1

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

@@ -0,0 +1,376 @@
+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 PermissionResponse {
+  approved: boolean
+  status: string
+}
+
+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
+  }
+}
+
+function extractMessageId(context: unknown): string | null {
+  if (!context || typeof context !== "object") {
+    return null
+  }
+
+  const candidate = (context as { messageID?: unknown; messageId?: unknown; message_id?: unknown })
+  const raw = candidate.messageID ?? candidate.messageId ?? candidate.message_id
+  if (typeof raw === "string" && raw.trim().length > 0) {
+    return raw
+  }
+  if (typeof raw === "number" && Number.isFinite(raw)) {
+    return String(raw)
+  }
+  return null
+}
+
+function extractCallId(context: unknown): string | null {
+  if (!context || typeof context !== "object") {
+    return null
+  }
+
+  const candidate = (context as { callID?: unknown; callId?: unknown; call_id?: unknown })
+  const raw = candidate.callID ?? candidate.callId ?? candidate.call_id
+  if (typeof raw === "string" && raw.trim().length > 0) {
+    return raw
+  }
+  return null
+}
+
+function assertTargetType(targetType: string): void {
+  if (targetType !== "prompt" && targetType !== "workflow") {
+    throw new Error('target_type must be "prompt" or "workflow".')
+  }
+}
+
+function assertNonEmpty(value: string, label: string): void {
+  if (value.trim().length === 0) {
+    throw new Error(`${label} is required.`)
+  }
+}
+
+function ensureMessageAndCallIds(context: unknown): { messageId: string; callId: string } {
+  const messageId = extractMessageId(context)
+  const callId = extractCallId(context)
+
+  if (!messageId) {
+    throw new Error("Could not determine message id from tool context.")
+  }
+
+  if (!callId) {
+    throw new Error("Could not determine call id from tool context.")
+  }
+
+  return { messageId, callId }
+}
+
+async function rejectCronjobPermission(
+  sessionID: string,
+  permissionId: string
+): Promise<void> {
+  await fetch(`${getApiBaseUrl()}/api/workflows/permission-reject/${permissionId}`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${sessionID}`,
+    },
+  })
+}
+
+async function requestCronjobPermission(
+  sessionID: string,
+  messageID: string,
+  callID: string,
+  action: string
+): Promise<void> {
+  const response = await fetch(`${getApiBaseUrl()}/api/workflows/request-permission`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${sessionID}`,
+    },
+    body: JSON.stringify({
+      message_id: messageID,
+      call_id: callID,
+    }),
+  })
+
+  if (!response.ok) {
+    const message = await readErrorMessageFromResponse(
+      response,
+      `Failed to request permission (HTTP ${response.status})`
+    )
+    throw new Error(message)
+  }
+
+  const data = (await response.json()) as { permission_id: string }
+  const permissionId = data.permission_id
+
+  const maxAttempts = 300
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    await new Promise((resolve) => setTimeout(resolve, 1000))
+
+    const statusResponse = await fetch(
+      `${getApiBaseUrl()}/api/workflows/permission-status/${permissionId}`,
+      {
+        headers: {
+          Authorization: `Bearer ${sessionID}`,
+        },
+      }
+    )
+
+    if (!statusResponse.ok) {
+      continue
+    }
+
+    const statusData = (await statusResponse.json()) as PermissionResponse
+
+    if (statusData.status === "approved") {
+      return
+    }
+    if (statusData.status === "rejected") {
+      throw new Error(`User denied permission to ${action}.`)
+    }
+  }
+
+  try {
+    await rejectCronjobPermission(sessionID, permissionId)
+  } catch {
+    // Best-effort cleanup only; preserve the timeout error below.
+  }
+  throw new Error("Permission request timed out")
+}
+
+async function fetchJsonWithError(
+  url: string,
+  init: RequestInit,
+  fallbackMessage: string
+): Promise<unknown> {
+  const response = await fetch(url, init)
+  if (!response.ok) {
+    const errorMessage = await readErrorMessageFromResponse(response, fallbackMessage)
+    throw new Error(errorMessage)
+  }
+  return await response.json()
+}
+
+export const ManageCronjobsPlugin: 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: {
+      listCronjobs: tool({
+        description:
+          "List the current user's TeamCopilot cronjobs, including ids needed for editCronjob and runCronjobNow. This is read-only and does not require approval.",
+        args: {},
+        async execute(_args, context) {
+          const { sessionID } = context
+          const authSessionID = await resolveRootSessionID(sessionID)
+
+          const payload = await fetchJsonWithError(
+            `${getApiBaseUrl()}/api/cronjobs`,
+            {
+              method: "GET",
+              headers: {
+                Authorization: `Bearer ${authSessionID}`,
+              },
+            },
+            "Failed to list cronjobs"
+          )
+
+          return JSON.stringify(payload, null, 2)
+        },
+      }),
+      createCronjob: tool({
+        description:
+          "Create and schedule a TeamCopilot cronjob. Requires user approval for this tool call. Future scheduled runs of the created cronjob will not ask for approval again.",
+        args: {
+          name: tool.schema.string().describe("Human-readable cronjob name."),
+          enabled: tool.schema.boolean().describe("Whether the cronjob should be scheduled immediately after creation."),
+          target_type: tool.schema.enum(["prompt", "workflow"]).describe("Use prompt for an agent prompt cronjob, or workflow for a direct workflow cronjob."),
+          prompt: tool.schema.string().optional().describe("Required when target_type is prompt. The unattended cronjob prompt to run."),
+          allow_workflow_runs_without_permission: tool.schema.boolean().optional().default(true).describe("Prompt cronjobs only. If true, workflows invoked by that cronjob run without additional user approval during scheduled execution."),
+          workflow_slug: tool.schema.string().optional().describe("Required when target_type is workflow. Workflow slug to run."),
+          workflow_inputs: tool.schema.record(tool.schema.string(), tool.schema.unknown()).optional().default({}).describe("Workflow cronjobs only. Saved workflow input arguments."),
+          cron_expression: tool.schema.string().describe("Five-field cron expression, for example '0 9 * * 1-5'."),
+          timezone: tool.schema.string().describe("IANA timezone, for example 'UTC', 'Asia/Kolkata', or 'America/Los_Angeles'."),
+        },
+        async execute(args, context) {
+          const { sessionID } = context
+          const authSessionID = await resolveRootSessionID(sessionID)
+          const { messageId, callId } = ensureMessageAndCallIds(context)
+
+          assertNonEmpty(args.name, "name")
+          assertTargetType(args.target_type)
+          assertNonEmpty(args.cron_expression, "cron_expression")
+          assertNonEmpty(args.timezone, "timezone")
+          if (args.target_type === "prompt") {
+            assertNonEmpty(args.prompt ?? "", "prompt")
+          }
+          if (args.target_type === "workflow") {
+            assertNonEmpty(args.workflow_slug ?? "", "workflow_slug")
+          }
+
+          await requestCronjobPermission(authSessionID, messageId, callId, "create this cronjob")
+
+          const payload = await fetchJsonWithError(
+            `${getApiBaseUrl()}/api/cronjobs`,
+            {
+              method: "POST",
+              headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${authSessionID}`,
+              },
+              body: JSON.stringify(args),
+            },
+            "Failed to create cronjob"
+          )
+
+          return JSON.stringify(payload, null, 2)
+        },
+      }),
+      editCronjob: tool({
+        description:
+          "Edit an existing TeamCopilot cronjob. Requires user approval for this tool call. Future scheduled runs of the edited cronjob will not ask for approval again.",
+        args: {
+          id: tool.schema.string().describe("Cronjob id to edit."),
+          name: tool.schema.string().optional().describe("New human-readable cronjob name."),
+          enabled: tool.schema.boolean().optional().describe("Whether the cronjob should be scheduled."),
+          target_type: tool.schema.enum(["prompt", "workflow"]).optional().describe("Use prompt for an agent prompt cronjob, or workflow for a direct workflow cronjob."),
+          prompt: tool.schema.string().optional().describe("Prompt cronjob task text."),
+          allow_workflow_runs_without_permission: tool.schema.boolean().optional().describe("Prompt cronjobs only. If true, workflows invoked by that cronjob run without additional user approval during scheduled execution."),
+          workflow_slug: tool.schema.string().optional().describe("Workflow slug for workflow cronjobs."),
+          workflow_inputs: tool.schema.record(tool.schema.string(), tool.schema.unknown()).optional().describe("Saved workflow input arguments."),
+          cron_expression: tool.schema.string().optional().describe("Five-field cron expression, for example '0 9 * * 1-5'."),
+          timezone: tool.schema.string().optional().describe("IANA timezone, for example 'UTC', 'Asia/Kolkata', or 'America/Los_Angeles'."),
+        },
+        async execute(args, context) {
+          const { sessionID } = context
+          const authSessionID = await resolveRootSessionID(sessionID)
+          const { messageId, callId } = ensureMessageAndCallIds(context)
+
+          assertNonEmpty(args.id, "id")
+          if (args.target_type !== undefined) {
+            assertTargetType(args.target_type)
+          }
+          if (args.name !== undefined) {
+            assertNonEmpty(args.name, "name")
+          }
+          if (args.cron_expression !== undefined) {
+            assertNonEmpty(args.cron_expression, "cron_expression")
+          }
+          if (args.timezone !== undefined) {
+            assertNonEmpty(args.timezone, "timezone")
+          }
+
+          const { id, ...patch } = args
+          if (Object.keys(patch).length === 0) {
+            throw new Error("At least one cronjob field must be provided to edit.")
+          }
+
+          await requestCronjobPermission(authSessionID, messageId, callId, "edit this cronjob")
+
+          const payload = await fetchJsonWithError(
+            `${getApiBaseUrl()}/api/cronjobs/${encodeURIComponent(id)}`,
+            {
+              method: "PATCH",
+              headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${authSessionID}`,
+              },
+              body: JSON.stringify(patch),
+            },
+            "Failed to edit cronjob"
+          )
+
+          return JSON.stringify(payload, null, 2)
+        },
+      }),
+      runCronjobNow: tool({
+        description:
+          "Run an existing TeamCopilot cronjob immediately. Requires user approval for this tool call.",
+        args: {
+          id: tool.schema.string().describe("Cronjob id to run now."),
+        },
+        async execute(args, context) {
+          const { sessionID } = context
+          const authSessionID = await resolveRootSessionID(sessionID)
+          const { messageId, callId } = ensureMessageAndCallIds(context)
+
+          assertNonEmpty(args.id, "id")
+
+          await requestCronjobPermission(authSessionID, messageId, callId, "run this cronjob now")
+
+          const payload = await fetchJsonWithError(
+            `${getApiBaseUrl()}/api/cronjobs/${encodeURIComponent(args.id)}/run-now`,
+            {
+              method: "POST",
+              headers: {
+                Authorization: `Bearer ${authSessionID}`,
+              },
+            },
+            "Failed to run cronjob now"
+          )
+
+          return JSON.stringify(payload, null, 2)
+        },
+      }),
+    },
+  }
+}
+
+export default ManageCronjobsPlugin

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

@@ -0,0 +1,107 @@
+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 MarkCronjobCompletedPlugin: 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: {
+      markCronjobCompleted: tool({
+        description:
+          "Mark the current TeamCopilot cronjob run as successfully completed. Use this exactly once, only after all requested cronjob work is complete and all TeamCopilot cronjob todos have been finished. This tool fails while any cronjob todo is still pending or in progress.",
+        args: {
+          summary: tool.schema
+            .string()
+            .describe("A concise summary of what the cronjob completed, suitable for the cronjob run history."),
+        },
+        async execute(args, context) {
+          const { sessionID } = context
+          const authSessionID = await resolveRootSessionID(sessionID)
+          const summary = args.summary?.trim()
+
+          if (!summary) {
+            throw new Error("summary is required")
+          }
+
+          const response = await fetch(`${getApiBaseUrl()}/api/cronjobs/runs/complete-current`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `Bearer ${authSessionID}`,
+            },
+            body: JSON.stringify({ summary }),
+          })
+
+          if (!response.ok) {
+            const errorMessage = await readErrorMessageFromResponse(
+              response,
+              `Failed to mark cronjob completed (HTTP ${response.status})`
+            )
+            throw new Error(errorMessage)
+          }
+
+          return JSON.stringify({ success: true, summary })
+        },
+      }),
+    },
+  }
+}
+
+export default MarkCronjobCompletedPlugin

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

@@ -0,0 +1,107 @@
+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 MarkCronjobFailedPlugin: 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: {
+      markCronjobFailed: tool({
+        description:
+          "Mark the current TeamCopilot cronjob run as failed. Use this exactly once when the cronjob task cannot be completed because of a non-recoverable issue, and include a concise reason suitable for cronjob run history.",
+        args: {
+          summary: tool.schema
+            .string()
+            .describe("A concise reason explaining why the cronjob could not complete."),
+        },
+        async execute(args, context) {
+          const { sessionID } = context
+          const authSessionID = await resolveRootSessionID(sessionID)
+          const summary = args.summary?.trim()
+
+          if (!summary) {
+            throw new Error("summary is required")
+          }
+
+          const response = await fetch(`${getApiBaseUrl()}/api/cronjobs/runs/fail-current`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `Bearer ${authSessionID}`,
+            },
+            body: JSON.stringify({ summary }),
+          })
+
+          if (!response.ok) {
+            const errorMessage = await readErrorMessageFromResponse(
+              response,
+              `Failed to mark cronjob failed (HTTP ${response.status})`
+            )
+            throw new Error(errorMessage)
+          }
+
+          return JSON.stringify({ success: true, summary })
+        },
+      }),
+    },
+  }
+}
+
+export default MarkCronjobFailedPlugin

package/dist/workspace_files/AGENTS.md

@@ -1,6 +1,6 @@
 # TeamCopilot Agent Instructions
 
-You are TeamCopilot agent. So when asked you who you are, you must start with "I am the TeamCopilot agent." and then continue with your reply.
+You are TeamCopilot agent.
 
 TeamCopilot is a multi-user AI agent platform for teams that want shared agent capabilities with permissions. Users can create custom agent skills and workflows (python scripts), and share them with members of their team in a secure and controlled environment. This document is your operating manual for working within this directory (called workspace). Follow these conventions strictly when creating, updating, or running workflows and custom skills.
 
@@ -531,6 +531,56 @@ When you need a quick inventory before semantic search or selection:
 2. If needed, then use `findSimilarWorkflow` to rank by semantic relevance.
 3. Choose the best candidate and proceed with `runWorkflow` (or update/create flow as needed).
 
+---
+
+## Section 3: Cronjobs
+
+### What is a Cronjob?
+
+A **cronjob** is a scheduled TeamCopilot task owned by the current user. Cronjobs can run either:
+- A prompt-based agent session on a recurring schedule
+- A workflow directly with saved workflow input arguments
+
+Cronjobs are configured through platform APIs via dedicated cronjob tools. Do not create, edit, or run cronjobs with raw HTTP calls, direct database writes, or shell scripts.
+
+### Required Cronjob Tools
+
+- `listCronjobs` — list the current user's cronjobs. Use this to find cronjob ids before editing or running an existing cronjob.
+- `createCronjob` — create and schedule a cronjob. This tool requires explicit user permission during execution.
+- `editCronjob` — edit an existing cronjob. This tool requires explicit user permission during execution.
+- `runCronjobNow` — run an existing cronjob immediately. This tool requires explicit user permission during execution.
+
+### Cronjob Rules
+
+- Use cronjob tools when the user asks you to schedule recurring work.
+- After a cronjob is created or edited, its future scheduled runs are already authorized by that approved tool call. Do not ask the user to approve each future scheduled run.
+- If the user asks to delete a cronjob, tell them that you cannot delete it and that they should delete it using the UI. You can only disable it if they want to.
+- For workflow cronjobs, provide all required workflow input arguments during creation or editing.
+- For prompt cronjobs, write prompts so the scheduled agent can finish without user input unless user attention is truly required.
+- In prompt cronjobs, unless it's a very simple task, prefer creating a custom skill first, and then mentioning to use that skill in the prompt. We want to keep the cronjob prompt as small as possible.
+
+### Example: Creating a Cronjob
+
+When asked to "Schedule a repo health check every weekday at 9 AM":
+
+1. Use `createCronjob` with:
+   - `name`
+   - `enabled`
+   - `target_type`
+   - `prompt` or `workflow_slug` plus `workflow_inputs`
+   - `cron_expression`
+   - `timezone`
+2. Wait for the user to approve the tool permission prompt.
+3. Tell the user that future scheduled runs will not ask for approval again.
+
+### Example: Editing or Running a Cronjob
+
+When asked to change or immediately run an existing cronjob:
+
+1. Use `listCronjobs` to find the correct cronjob id.
+2. Use `editCronjob` or `runCronjobNow`.
+3. Wait for the user to approve the tool permission prompt.
+
 ## Example: Finding and Using a Skill
 
 When a user asks for behavior that may already be captured as reusable instructions:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teamcopilot",
-  "version": "0.3.6",
+  "version": "0.4.1",
   "description": "A shared AI Agent for Teams",
   "homepage": "https://teamcopilot.ai",
   "repository": {