@stigmer/cli 3.5.3 → 3.6.0

package/src/resources/mutate-verbs.integration.test.ts

@@ -34,9 +34,15 @@ import { EnvironmentQueryController } from "@stigmer/protos/ai/stigmer/agentic/e
 import { McpServerSchema } from "@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/api_pb";
 import { McpServerCommandController } from "@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/command_pb";
 import { McpServerQueryController } from "@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/query_pb";
+import { ScheduleSchema } from "@stigmer/protos/ai/stigmer/agentic/schedule/v1/api_pb";
+import { ScheduleCommandController } from "@stigmer/protos/ai/stigmer/agentic/schedule/v1/command_pb";
+import { ScheduleQueryController } from "@stigmer/protos/ai/stigmer/agentic/schedule/v1/query_pb";
 import { WorkflowSchema } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/api_pb";
 import { WorkflowCommandController } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/command_pb";
 import { WorkflowQueryController } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/query_pb";
+import { WorkflowInstanceSchema } from "@stigmer/protos/ai/stigmer/agentic/workflowinstance/v1/api_pb";
+import { WorkflowInstanceCommandController } from "@stigmer/protos/ai/stigmer/agentic/workflowinstance/v1/command_pb";
+import { WorkflowInstanceQueryController } from "@stigmer/protos/ai/stigmer/agentic/workflowinstance/v1/query_pb";
 import { createNodeClient, normalizeEndpoint } from "@stigmer/sdk/node";
 import type { Stigmer } from "@stigmer/sdk";
 import { createServer as createHttp2Server, type Http2Server, type ServerHttp2Session } from "node:http2";
@@ -85,6 +91,14 @@ const knownChannelApp = create(ChannelAppSchema, {
   metadata: { name: "clinic-meta-app", slug: "clinic-meta-app", org: "acme", id: "chapp_1" },
 });
 
+const knownSchedule = create(ScheduleSchema, {
+  metadata: { name: "daily-fee-reminders", slug: "daily-fee-reminders", org: "acme", id: "sch_1" },
+});
+
+const knownWorkflowInstance = create(WorkflowInstanceSchema, {
+  metadata: { name: "deploy-default", slug: "deploy-default", org: "acme", id: "win_1" },
+});
+
 // Pending execution (cancellable) vs. an already-terminal one.
 const pendingExecution = create(AgentExecutionSchema, {
   metadata: { id: "aex_run" },
@@ -110,8 +124,11 @@ let tagCalls: { workflowId: string; versionHash: string; tag: string }[] = [];
 let datastoreDeletes: { resourceId: string; force: boolean }[] = [];
 let environmentDeletes: { resourceId: string; force: boolean }[] = [];
 let channelAppDeletes: { resourceId: string; force: boolean }[] = [];
-// agent_channel's delete is a typed ID — no force field exists on the wire.
+// agent_channel, schedule, and workflow_instance delete by typed ID — no
+// force field exists on their wire contracts.
 let channelDeleteIds: string[] = [];
+let scheduleDeleteIds: string[] = [];
+let workflowInstanceDeleteIds: string[] = [];
 
 beforeEach(() => {
   cancelCalls = [];
@@ -120,6 +137,8 @@ beforeEach(() => {
   environmentDeletes = [];
   channelAppDeletes = [];
   channelDeleteIds = [];
+  scheduleDeleteIds = [];
+  workflowInstanceDeleteIds = [];
 });
 
 beforeAll(async () => {
@@ -216,6 +235,32 @@ beforeAll(async () => {
       },
     });
 
+    router.service(ScheduleQueryController, {
+      getByReference: (req) => {
+        if (req.slug !== "daily-fee-reminders") throw new ConnectError("schedule not found", Code.NotFound);
+        return knownSchedule;
+      },
+    });
+    router.service(ScheduleCommandController, {
+      delete: (req) => {
+        scheduleDeleteIds.push(req.value);
+        return knownSchedule;
+      },
+    });
+
+    router.service(WorkflowInstanceQueryController, {
+      getByReference: (req) => {
+        if (req.slug !== "deploy-default") throw new ConnectError("workflow instance not found", Code.NotFound);
+        return knownWorkflowInstance;
+      },
+    });
+    router.service(WorkflowInstanceCommandController, {
+      delete: (req) => {
+        workflowInstanceDeleteIds.push(req.value);
+        return knownWorkflowInstance;
+      },
+    });
+
     router.service(WorkflowQueryController, {
       getByReference: (req) => {
         if (req.slug !== "deploy") throw new ConnectError("workflow not found", Code.NotFound);
@@ -306,22 +351,51 @@ describe("delete (standard kinds)", () => {
     expect(classify(err)?.exitCode).toBe(ExitCode.NotFound);
   });
 
+  it("deletes a schedule via its typed ID (tears down the Temporal artifact server-side)", async () => {
+    const plan = await planDelete(client, "schedule", "daily-fee-reminders", "acme");
+    const result = await plan.perform();
+    expect(result.status).toBe("success");
+    expect(result.message).toBe("Schedule deleted successfully");
+    expect(scheduleDeleteIds).toEqual(["sch_1"]);
+  });
+
+  it("deletes a workflow instance via its typed ID", async () => {
+    const plan = await planDelete(client, "workflow-instance", "deploy-default", "acme");
+    const result = await plan.perform();
+    expect(result.status).toBe("success");
+    expect(result.message).toBe("Workflow Instance deleted successfully");
+    expect(workflowInstanceDeleteIds).toEqual(["win_1"]);
+  });
+
   it("rejects an unknown type and lists exactly the wired types", async () => {
     const err = await planDelete(client, "bogus", "x", "acme").catch((e) => e);
     expect(classify(err)?.exitCode).toBe(ExitCode.Usage);
     // The list is derived from DELETE_HANDLERS (+ the two special cases), so
-    // it must name the wired kinds and never the declared-but-unwired ones.
+    // it must name the wired kinds and never the narrowed ones (#354).
     const message = String(err.message);
-    for (const wired of ["datastore", "environment", "agentchannel", "channelapp", "execution", "organization"]) {
+    for (const wired of [
+      "datastore",
+      "environment",
+      "agentchannel",
+      "channelapp",
+      "schedule",
+      "workflowinstance",
+      "execution",
+      "organization",
+    ]) {
       expect(message).toContain(wired);
     }
     expect(message).not.toContain("session");
     expect(message).not.toContain("oauthapp");
   });
 
-  it("rejects a kind that has no delete handler with a usage error", async () => {
+  it("rejects a narrowed kind at the verb gate with a usage error", async () => {
+    // session's delete verb is narrowed out of the matrix
+    // (stigmer/stigmer#354), so the refusal now happens at the verb-support
+    // gate ("does not support") rather than the dispatch fall-through.
     const err = await planDelete(client, "session", "ses_1", "acme").catch((e) => e);
     expect(classify(err)?.exitCode).toBe(ExitCode.Usage);
+    expect(String(err.message)).toContain("does not support");
   });
 });
 

package/src/resources/read-verbs.integration.test.ts

@@ -21,6 +21,8 @@ import { ChannelAppSchema } from "@stigmer/protos/ai/stigmer/agentic/channelapp/
 import { ChannelAppQueryController } from "@stigmer/protos/ai/stigmer/agentic/channelapp/v1/query_pb";
 import { EnvironmentSchema } from "@stigmer/protos/ai/stigmer/agentic/environment/v1/api_pb";
 import { EnvironmentQueryController } from "@stigmer/protos/ai/stigmer/agentic/environment/v1/query_pb";
+import { ScheduleSchema } from "@stigmer/protos/ai/stigmer/agentic/schedule/v1/api_pb";
+import { ScheduleQueryController } from "@stigmer/protos/ai/stigmer/agentic/schedule/v1/query_pb";
 import { ApiResourceKind } from "@stigmer/protos/ai/stigmer/commons/apiresource/apiresourcekind/api_resource_kind_pb";
 import { ApiKeySchema } from "@stigmer/protos/ai/stigmer/iam/apikey/v1/api_pb";
 import { ApiKeyQueryController } from "@stigmer/protos/ai/stigmer/iam/apikey/v1/query_pb";
@@ -142,6 +144,44 @@ const secondChannelApp = create(ChannelAppSchema, {
   },
 });
 
+// Spec/status populated to exercise every SCHEDULE_TABLE column — and the
+// exact condition the table exists to surface (stigmer/stigmer#352): the
+// owner's switch is ON (spec.enabled) while the platform's failure latch is
+// SET (status.paused_reason), two different states with two different
+// remedies.
+const pausedSchedule = create(ScheduleSchema, {
+  apiVersion: "agentic.stigmer.ai/v1",
+  kind: "Schedule",
+  metadata: { name: "daily-fee-reminders", slug: "daily-fee-reminders", org: "acme", id: "sch_1" },
+  spec: {
+    cron: "0 9 * * *",
+    timeZone: "Asia/Kolkata",
+    enabled: true,
+    target: {
+      case: "agent",
+      value: { agentRef: { kind: ApiResourceKind.agent, org: "acme", slug: "clinic-assistant" } },
+    },
+  },
+  status: { pausedReason: "5 consecutive failed runs", consecutiveFailures: 5 },
+});
+
+// Owner-disabled and never fired: empty status, so the row must derive
+// "active" from an absent paused_reason and print no bogus timestamps.
+const disabledSchedule = create(ScheduleSchema, {
+  apiVersion: "agentic.stigmer.ai/v1",
+  kind: "Schedule",
+  metadata: { name: "weekly-digest", slug: "weekly-digest", org: "acme", id: "sch_2" },
+  spec: {
+    cron: "30 6 * * 1",
+    timeZone: "UTC",
+    enabled: false,
+    target: {
+      case: "agent",
+      value: { agentRef: { kind: ApiResourceKind.agent, org: "acme", slug: "reviewer" } },
+    },
+  },
+});
+
 let backend: Http2Server;
 let client: Stigmer;
 const openSessions = new Set<ServerHttp2Session>();
@@ -226,6 +266,20 @@ beforeAll(async () => {
         return { entries: [knownChannelApp, secondChannelApp] };
       },
     });
+    router.service(ScheduleQueryController, {
+      get: (req) => {
+        if (req.value !== "sch_1") throw new ConnectError("schedule not found", Code.NotFound);
+        return pausedSchedule;
+      },
+      getByReference: (req) => {
+        if (req.slug !== "daily-fee-reminders") throw new ConnectError("schedule not found", Code.NotFound);
+        return pausedSchedule;
+      },
+      list: (req) => {
+        if (req.org !== "acme") throw new ConnectError("org is required", Code.InvalidArgument);
+        return { totalCount: 2, items: [pausedSchedule, disabledSchedule] };
+      },
+    });
   };
   backend = createHttp2Server(connectNodeAdapter({ routes }));
   backend.on("session", (session) => {
@@ -341,6 +395,27 @@ describe("get integration", () => {
     });
   });
 
+  it("fetches a schedule by org/slug and renders backend protojson", async () => {
+    const { schema, message } = await fetchResource(client, ApiResourceKind.schedule, {
+      kind: "ref",
+      org: "acme",
+      slug: "daily-fee-reminders",
+    });
+    const rendered = JSON.parse(renderResource(schema, message, "json"));
+    expect(rendered).toEqual(toJson(ScheduleSchema, pausedSchedule, { useProtoFieldName: true }));
+  });
+
+  it("fetches a schedule by ID, exposing the pause diagnosis get exists for", async () => {
+    const { message } = await fetchResource(client, ApiResourceKind.schedule, { kind: "id", id: "sch_1" });
+    // The full resource is where an operator reads WHY the platform paused
+    // a schedule (paused_reason + the streak) — the list table only flags it.
+    expect(JSON.parse(renderResource(ScheduleSchema, message, "json"))).toMatchObject({
+      metadata: { id: "sch_1" },
+      spec: { enabled: true },
+      status: { paused_reason: "5 consecutive failed runs", consecutive_failures: 5 },
+    });
+  });
+
   it("maps a NotFound backend error to ExitCode.NotFound", async () => {
     const err = await fetchResource(client, ApiResourceKind.agent, { kind: "id", id: "missing" }).catch((e) => e);
     const classified = classify(err);
@@ -348,8 +423,11 @@ describe("get integration", () => {
   });
 
   it("rejects an unsupported kind with a usage error", async () => {
-    // session declares Get in the registry but has no get binding — the
-    // canonical still-unwired kind (environment gained a binding).
+    // session's read verbs are narrowed out of the verb matrix
+    // (stigmer/stigmer#354): the command layer refuses at the gate, and this
+    // resource-layer fallback answers anyone bypassing the gate. Wiring
+    // session get requires BOTH the binding and the matrix line — the
+    // registry conformance test enforces the pairing.
     const err = await fetchResource(client, ApiResourceKind.session, { kind: "id", id: "x" }).catch((e) => e);
     expect(classify(err)?.exitCode).toBe(ExitCode.Usage);
   });
@@ -441,10 +519,51 @@ describe("list integration", () => {
     expect(JSON.parse(out)).toEqual([toJson(ChannelAppSchema, knownChannelApp, { useProtoFieldName: true })]);
   });
 
+  it("lists schedules as a table keeping the owner switch and the platform latch distinct", async () => {
+    const out = await listResources(client, ApiResourceKind.schedule, "acme", 50, "table");
+    for (const header of ["ID", "SLUG", "TARGET", "CRON", "TZ", "ENABLED", "STATE"]) {
+      expect(out).toContain(header);
+    }
+    const rows = out.split("\n");
+    // The stigmer/stigmer#352 condition: enabled by the owner, paused by the
+    // platform. Collapsing these into one column would hide exactly this.
+    const pausedRow = rows.find((line) => line.includes("sch_1"));
+    expect(pausedRow).toContain("acme/clinic-assistant");
+    expect(pausedRow).toContain("0 9 * * *");
+    expect(pausedRow).toContain("Asia/Kolkata");
+    expect(pausedRow).toContain("true");
+    expect(pausedRow).toContain("paused");
+    // Owner-disabled with an empty status: derived state is "active" (no
+    // platform latch), and the absent timestamps render nothing bogus.
+    const disabledRow = rows.find((line) => line.includes("sch_2"));
+    expect(disabledRow).toContain("false");
+    expect(disabledRow).toContain("active");
+    expect(disabledRow).not.toContain("paused");
+  });
+
+  it("lists schedules as JSON matching backend protojson", async () => {
+    const out = await listResources(client, ApiResourceKind.schedule, "acme", 50, "json");
+    expect(JSON.parse(out)).toEqual([
+      toJson(ScheduleSchema, pausedSchedule, { useProtoFieldName: true }),
+      toJson(ScheduleSchema, disabledSchedule, { useProtoFieldName: true }),
+    ]);
+  });
+
+  it("refuses to list schedules without an org context, before any RPC", async () => {
+    // ListSchedulesRequest requires org (min_len 1); an unset cloud context
+    // resolves to "". The branch refuses with actionable copy instead of
+    // relaying the server's raw validation error.
+    const err = await listResources(client, ApiResourceKind.schedule, "", 50, "table").catch((e) => e);
+    expect(classify(err)?.exitCode).toBe(ExitCode.Usage);
+    expect(String(err.message)).toContain("--org");
+  });
+
   it("rejects a kind whose list is unwired with a usage error", async () => {
-    // agent_share declares List in the registry but has no list branch —
-    // the canonical still-unwired list kind (the three cutover kinds and
-    // environment gained branches).
+    // agent_share's read verbs are narrowed out of the verb matrix
+    // (stigmer/stigmer#354): the command layer refuses at the gate, and this
+    // resource-layer fallback answers anyone bypassing the gate. Wiring
+    // agent_share list requires BOTH the LIST_HANDLERS entry and the matrix
+    // line — the registry conformance test enforces the pairing.
     const err = await listResources(client, ApiResourceKind.agent_share, "acme", 50, "json").catch((e) => e);
     expect(classify(err)?.exitCode).toBe(ExitCode.Usage);
   });

package/src/resources/reference.ts

@@ -86,6 +86,11 @@ export function isSessionId(ref: string): boolean {
   return hasKindPrefix(ref, idPrefixFor(ApiResourceKind.session));
 }
 
+/** True if `ref` carries the schedule ID prefix (`sch_…`/`sch-…`). */
+export function isScheduleId(ref: string): boolean {
+  return hasKindPrefix(ref, idPrefixFor(ApiResourceKind.schedule));
+}
+
 /**
  * True if `ref` starts with ANY known resource-ID prefix (length-agnostic).
  * Mirrors Go's reference.HasResourceIDPrefix: use it to detect *intent* (the

package/src/resources/schedule.ts

@@ -0,0 +1,115 @@
+// `schedule resume` dispatch: clear a platform auto-pause from a schedule
+// and report what was cleared.
+//
+// "Paused" is the platform's latch (status.paused_reason, written after
+// repeated failed runs), distinct from "disabled", the owner's switch
+// (spec.enabled) — two words, two levers (see docs/vocabulary.md). The
+// resume RPC is deliberately the only path that clears the latch: applying
+// a manifest preserves status verbatim, so no declarative workflow can
+// silently un-pause a failing schedule.
+//
+// The pre-state read exists for honest messaging only: the RPC is
+// idempotent and its response always shows a cleared latch, so "resumed"
+// versus "was not paused" can only be told apart by looking first. The
+// resume call is made either way — on the no-op path it doubles as a
+// harmless re-arm of the schedule's clock.
+
+import { timestampDate } from "@bufbuild/protobuf/wkt";
+import type { Schedule } from "@stigmer/protos/ai/stigmer/agentic/schedule/v1/api_pb";
+import type { Stigmer } from "@stigmer/sdk";
+import { UsageError } from "../errors/index.js";
+import { CommandResult } from "../output/index.js";
+import { parseReference } from "./reference.js";
+
+/** The schedule kind's canonical id prefix (proto kind_meta). */
+const SCHEDULE_ID_PREFIX = "sch";
+
+/**
+ * Resolve `ref` (a `sch_…` id, `org/slug`, or bare slug against `org`),
+ * clear its platform pause, and describe the outcome.
+ */
+export async function resumeSchedule(stigmer: Stigmer, ref: string, org: string): Promise<CommandResult> {
+  const before = await loadSchedule(stigmer, ref, org);
+  const id = before.metadata?.id ?? "";
+  if (id === "") {
+    throw new UsageError(`Schedule '${ref}' has no id — cannot resume`);
+  }
+
+  const wasPausedReason = before.status?.pausedReason ?? "";
+  const wasFailures = before.status?.consecutiveFailures ?? 0;
+
+  const resumed = await stigmer.schedule.resume(id);
+
+  return describeOutcome(resumed, wasPausedReason, wasFailures);
+}
+
+async function loadSchedule(stigmer: Stigmer, ref: string, org: string): Promise<Schedule> {
+  const parsed = parseReference(ref, org, SCHEDULE_ID_PREFIX);
+  if (parsed.kind === "id") {
+    return stigmer.schedule.get(parsed.id);
+  }
+  if (parsed.org === "") {
+    throw new UsageError(
+      "organization not set\n\nSet it with:\n  stigmer config context set --org <org>\n  stigmer schedule resume --org <org> ...",
+    );
+  }
+  return stigmer.schedule.getByReference({ org: parsed.org, slug: parsed.slug });
+}
+
+/**
+ * Resolve `ref` (a `sch_…` id, `org/slug`, or bare slug against `org`) and
+ * fire it once, immediately (project DD-014).
+ *
+ * The fire is asynchronous: the RPC answers with the schedule, and the run
+ * lands on status (last_fire_at / last_execution_id) as it starts — the
+ * same observability contract cron fires have. Disabled and platform-paused
+ * schedules are refused by the server with teaching copy; the CLI relays
+ * the server's message verbatim (never pattern-match refusal text).
+ */
+export async function triggerSchedule(stigmer: Stigmer, ref: string, org: string): Promise<CommandResult> {
+  const before = await loadSchedule(stigmer, ref, org);
+  const id = before.metadata?.id ?? "";
+  if (id === "") {
+    throw new UsageError(`Schedule '${ref}' has no id — cannot trigger`);
+  }
+
+  const triggered = await stigmer.schedule.trigger(id);
+
+  const slug = triggered.metadata?.slug ?? "";
+  const name = triggered.metadata?.name || slug;
+  const result = CommandResult.success(`Schedule '${name}' triggered — a run is starting`);
+
+  const section = result.addSection();
+  const orgSlug = triggered.metadata?.org ? `${triggered.metadata.org}/${slug}` : slug;
+  section.field("Watch it land", `stigmer get schedule ${orgSlug} (status.last_execution_id)`);
+  if (triggered.status?.nextFireAt !== undefined) {
+    section.field("Next cron fire", timestampDate(triggered.status.nextFireAt).toISOString());
+  }
+
+  return result;
+}
+
+function describeOutcome(schedule: Schedule, wasPausedReason: string, wasFailures: number): CommandResult {
+  const slug = schedule.metadata?.slug ?? "";
+  const name = schedule.metadata?.name || slug;
+  const wasPaused = wasPausedReason !== "" || wasFailures > 0;
+
+  const result = CommandResult.success(
+    wasPaused ? `Schedule '${name}' resumed` : `Schedule '${name}' was not paused — nothing to clear`,
+  );
+
+  if (wasPaused) {
+    const section = result.addSection("Cleared");
+    if (wasPausedReason !== "") section.field("Pause reason", wasPausedReason);
+    if (wasFailures > 0) section.field("Consecutive failures", String(wasFailures));
+  }
+
+  if (schedule.spec?.enabled !== true) {
+    result.hint("This schedule is disabled (enabled: false) — it will not fire until you enable it:");
+    result.hint(`  edit the manifest to 'enabled: true' and run: stigmer apply -f <file>`);
+  } else if (schedule.status?.nextFireAt !== undefined) {
+    result.addSection().field("Next fire", timestampDate(schedule.status.nextFireAt).toISOString());
+  }
+
+  return result;
+}