@isomorph.ai/cli 0.10.3 → 0.10.4

package/dist/packages/harbour-cli/src/agent-setup.js

@@ -123,7 +123,7 @@ Rules live beside this file: \`core.md\` before the first edit; \`integrations.m
 | "ship it", "let my team try it" | show the person the three values in \`.isomorph/app.json\` (name, description, audience — "only you" when empty) and correct the file as they say; then \`isomorph deploy --app-root . --json\` (it runs the checks when needed and refuses once naming every blocker and its fix: relay that line; the app works meanwhile). Give them \`result.deployment.protectedUrl\`. \`--session-notes\`: what cost you time in Isomorph, or \`""\`. |
 | "make it live" | only after they have tried the preview: \`isomorph promote --operation <ref> --app-root . --confirm-tested --json\`. Report the production link, or that operator approval is pending. |
 | "stop it" | \`isomorph stop --app-root .\` (data kept); \`isomorph dev --app-root . --reset\` only when they ask to start over. |
-| "every day at 2pm", "send this automatically" | read \`jobs.md\` beside this skill first (a job cannot email as a person); write the job, run it once with \`isomorph jobs run\`, and say its sentence. |
+| "every day at 2pm", "send this automatically" | read \`jobs.md\` beside this skill first (the owner must enable background use of their account); write the job, run it once with \`isomorph jobs run\`, and say its sentence. |
 | "call this API", "a key for it", "run it in the background" | read \`server.md\` beside this skill first; server code goes in \`actions/\` or \`jobs/\`, a key by its name only. |
 
 A refusal names its layer, its reason and its fix: change that one thing, then run it again. A wait timeout is not a failure — work is still running: run the command it prints (\`${continueCommand("<ref>")}\`); never start a second deploy while one is running.

package/dist/packages/harbour-cli/src/check.js

@@ -2,7 +2,6 @@ import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { CliError } from "./output.js";
 import { DEPENDENT_READ_OPERATIONS, READ_OPERATIONS, kitPaths, readDeclaration, readKitLock, resourceNames, sourceDigest } from "./kit.js";
-import { jobIdentityProblems } from "./jobs.js";
 import { LocalRuntime, allocatePorts, freePort, installDependencies, nodePackageCommand, readDevLock, runningOrigin } from "./local-runtime.js";
 import { CLI_VERSION } from "./version.js";
 /**
@@ -30,8 +29,6 @@ const DETAIL_CAP = 200;
 export const CHECKS_FAILED_HINT = "Full detail is in .isomorph/check-report.json; fix what it reports, then run `isomorph check --app-root .` again.";
 /** The name the gate reports operation coverage under — the pipeline's rule for it. */
 export const FLOW_CHECK = "flow.check-failed";
-/** The CLI's own check over `jobs/`: a company operation a job calls that would run as a person. */
-export const JOBS_CHECK = "jobs.identity";
 /**
  * Runs the kit checks and writes `.isomorph/check-report.json`; a source
  * edit changes sourceDigest and so invalidates the previous report. The app's
@@ -60,10 +57,6 @@ export async function runChecks(root, options) {
     const gate = await runKitGate(root, { run, bundle, output, ...(options.fetch ? { fetch: options.fetch } : {}), ...(options.runtime ? { runtime: options.runtime } : {}), ...(options.pollMs ? { pollMs: options.pollMs } : {}) });
     for (const check of gate.checks)
         record(check);
-    // A job runs as the app: a company operation in `jobs/` that needs a person is refused here, not by the deployed schedule.
-    const jobs = await jobIdentityProblems(root, await readDeclaration(root));
-    if (jobs.length)
-        record({ name: JOBS_CHECK, status: "fail", detail: jobs.join("\n") });
     let integrations = "not tested";
     if (options.governance) {
         // Reads that could not run are one check the report carries as not_run with

package/dist/packages/harbour-cli/src/dev.js

@@ -5,7 +5,7 @@ import { join } from "node:path";
 import { createForwarder } from "./forwarder.js";
 import { GovernanceClient, ensureLinkedApp, fileDeclaredRequests, IDENTITY_WORDS, renderGrantGroup } from "./integrations.js";
 import { acquireDevLock, allocatePorts, assertMigrationNames, installDependencies, LocalRuntime, nodePackageCommand, pidAlive, readDevLock, recordDevChildren, releaseDevLock, runCommand, hasServerModules } from "./local-runtime.js";
-import { accessDigest, kitPaths, readDeclaration, readKitLock } from "./kit.js";
+import { accessDigest, kitPaths, readKitLock } from "./kit.js";
 import { startJobFixture } from "./job-fixture.js";
 import { CliError, safeError } from "./output.js";
 /**
@@ -127,7 +127,7 @@ export async function startDev(root, options) {
         // front of the session's gateway (job-fixture.ts: canned AI, company
         // systems refused), exactly what `isomorph jobs run` gives one job.
         if (await hasServerModules(root)) {
-            fixture = await startJobFixture({ upstreamPort: ports.gateway, real: false, declaration: await readDeclaration(root) });
+            fixture = await startJobFixture({ upstreamPort: ports.gateway, real: false });
             if (await runtime.startKitRuntime(session, fixture.url, options.output))
                 options.output("Started the app's server side (actions/ and jobs/) on the kit runtime.");
         }

package/dist/packages/harbour-cli/src/guide.js

@@ -91,11 +91,11 @@ const reply = await isomorph.ai.chat({ messages: [{ role: "user", content: \`Sum
 The starter calls no AI; add the one call when the person asks. The check's generated ai journey makes a real governed call locally through the development route with your \`isomorph login\`; in the pipeline it is answered by a canned completion and reported as not tested.`,
     jobs: `# Scheduled jobs
 
-A job runs as the app, never as a person: Gmail and user-mode Slack cannot run in one; \`slack.message.post\` declared \`"identity": "app"\` and warehouse reads can. Say so before building a scheduled email.
+A job runs as the app. It may use Gmail or user-mode Slack after the app owner explicitly enables background use of their connected account for that app and environment. Without that permission, user-mode calls are refused.
 
-Scheduled work lives only in \`jobs/<name>.ts\`: export one literal UTC cron as \`schedule\` and one default async handler. Never use \`setInterval\`, an effect or a browser timer as a scheduler; Isomorph runs the same declaration automatically after deployment on the app's server process, which owns the real clock. A job may call \`isomorph.ai.chat\` and app-identity company operations. A job with no \`schedule\` runs only when enqueued (server.md). Test it immediately: start \`isomorph dev\`, then \`isomorph jobs run <name> --app-root . --scheduled-at <matching-UTC-time> --json\` — local data, canned AI, company systems refused, nothing sent. Use \`--real\` only when the person explicitly asks to test the company action now and the exact action has development approval.
+Scheduled work lives only in \`jobs/<name>.ts\`: export one literal UTC cron as \`schedule\` and one default async handler. Never use \`setInterval\`, an effect or a browser timer as a scheduler; Isomorph runs the same declaration automatically after deployment on the app's server process, which owns the real clock. A job may call \`isomorph.ai.chat\` and approved company operations. A job with no \`schedule\` runs only when enqueued (server.md). Test it immediately: start \`isomorph dev\`, then \`isomorph jobs run <name> --app-root . --scheduled-at <matching-UTC-time> --json\` — local data, canned AI, company systems refused, nothing sent. Use \`--real\` only when the person explicitly asks to test the company action now and the exact action has development approval.
 
-A real scheduled send requires the person's explicit request, the exact operation and destination declared in \`.isomorph/integrations.json\`, and a grant for that environment; use one deterministic idempotency key for the business period and destination so a replay does not silently repost.
+A real scheduled send requires the app owner to enable background use of their account, the operation and resource declared in \`.isomorph/integrations.json\`, and a grant for that environment; use one deterministic idempotency key for the business period and destination so a replay does not silently repost.
 
 Tell them: "Your scheduled task is ready. I can test the app on your computer now. Company messages will start after the app is online and access is approved."`,
     server: `# Server code: actions, queued runs, outside APIs

package/dist/packages/harbour-cli/src/job-fixture.js

@@ -1,6 +1,5 @@
 import { createServer } from "node:http";
 import { pipe, readBody, reject } from "./forwarder.js";
-import { isOperationName, OPERATION_IDENTITIES } from "./kit.js";
 /**
  * The origin a job run talks to: a loopback server in front of the session's
  * gateway (an ordinary run) or the dev origin (`--real`).
@@ -13,24 +12,11 @@ import { isOperationName, OPERATION_IDENTITIES } from "./kit.js";
  * front of it proxies those paths to governance. Here, governed AI is answered
  * with the pipeline's canned completion (transformbuild/local_ai_fixture.go),
  * company systems are refused naming `--real` — a canned read would be data
- * the job then acts on — and, in both modes, an operation that runs as a
- * person is refused before it leaves the machine: a deployed job has no
- * person, and `--real` carries the builder's own identity through the
- * forwarder, so a scheduled Gmail send used to pass locally and fail deployed.
- * `isomorph check` refuses the same calls statically (jobs.ts `jobIdentityProblems`).
+ * the job then acts on. Real user-mode calls are marked as background runs,
+ * so governance requires the same explicit account permission as production.
  */
 export const AI_FIXTURE_COMPLETION = "AI is not exercised in the build fixture; this is a canned completion.";
 const BODY_LIMIT = 1024 * 1024;
-/** Whether a job's call to `operation` would run as a person: the request's `mode` or the declaration's identity says "user", or the catalog allows no app identity. */
-export function runsAsPerson(operation, declaration, connection, mode) {
-    if (!isOperationName(operation))
-        return false;
-    const identities = OPERATION_IDENTITIES[operation];
-    const chosen = mode === "app" || mode === "user" ? mode : declaration.connections[connection]?.operations[operation]?.identity;
-    return !identities.includes("app") || chosen === "user";
-}
-/** The refusal a person-only operation gets from a job, in every mode and in `check`. */
-export const personRefusal = (operation) => `${operation} runs as a person; a scheduled job runs as the app and has no person to act for, locally or deployed. Only app-identity operations run in a job.`;
 export async function startJobFixture(options) {
     const server = createServer((request, response) => {
         const path = (request.url ?? "/").split("?")[0];
@@ -58,15 +44,12 @@ function execute(request, response, raw, options) {
     }
     catch { /* the upstream answers a malformed body */ }
     const operation = String(body.operation ?? "");
-    if (runsAsPerson(operation, options.declaration, String(body.connection ?? ""), body.mode)) {
-        reject(response, 409, "CONFLICT", personRefusal(operation), "IDENTITY_MODE_MISMATCH", { operation, identity: "user" });
-        return;
-    }
     if (!options.real) {
         reject(response, 409, "CONFLICT", `${operation || "This operation"} is not exercised in a local job run. Run \`isomorph jobs run <name> --real\` to use the company's approved development access; the call then really runs.`, "LOCAL_FIXTURE", { operation });
         return;
     }
-    pipe(request, response, options.upstreamPort, {}, raw);
+    const forwarded = Buffer.from(JSON.stringify({ ...body, backgroundRun: true }));
+    pipe(request, response, options.upstreamPort, {}, forwarded);
 }
 function aiFixture(path) {
     return path === "/_harbour/ai/chat"

package/dist/packages/harbour-cli/src/jobs.js

@@ -3,8 +3,8 @@ import { join } from "node:path";
 import { pathToFileURL } from "node:url";
 import { CliError } from "./output.js";
 import { parseSessionEnv, readDevLock, readLocalSecrets, runCommand } from "./local-runtime.js";
-import { kitPaths, readDeclaration } from "./kit.js";
-import { personRefusal, runsAsPerson, startJobFixture } from "./job-fixture.js";
+import { kitPaths } from "./kit.js";
+import { startJobFixture } from "./job-fixture.js";
 const jobName = /^[a-z0-9][a-z0-9_-]{0,63}$/;
 const scheduleDeclaration = /^export\s+const\s+schedule\s*=\s*["']([^"']+)["']\s*;?\s*$/m;
 const scheduleExport = /\bexport\s+const\s+schedule\b/;
@@ -48,7 +48,7 @@ export async function runJob(root, name, scheduledAt, run = runCommand, real = f
     const runner = `const module = await import(${JSON.stringify(pathToFileURL(job.path).href)}); if (typeof module.default !== "function") throw new Error("job has no default handler"); await module.default({scheduledAt: process.env.ISOMORPH_SCHEDULED_AT});`;
     // The job talks to a loopback origin of its own (job-fixture.ts) in front of
     // the session's gateway, or of the dev origin under `--real`.
-    const fixture = await startJobFixture({ upstreamPort: real ? lock.ports.origin : lock.ports.gateway, real, declaration: await readDeclaration(root) });
+    const fixture = await startJobFixture({ upstreamPort: real ? lock.ports.origin : lock.ports.gateway, real });
     let result;
     try {
         result = await run(process.execPath, ["--experimental-strip-types", "--input-type=module", "--eval", runner], { cwd: root, env: { ...env, ISOMORPH_GATEWAY_URL: fixture.url, ISOMORPH_SCHEDULED_AT: timestamp } });
@@ -75,24 +75,3 @@ export function jobFailureReason(stderr) {
     return lines.find(line => /^[A-Z]\w*(?:Error|Exception)\b: \S/.test(line))
         ?? lines.find(line => /\b(?:error|exception|failed|cannot|unexpected|invalid|denied|refused)\b/i.test(line)) ?? lines[0] ?? "process exited non-zero";
 }
-const executeCall = /isomorph\s*\.\s*integrations\s*\.\s*execute\s*\(\s*["']([^"']+)["']\s*,\s*\{([^)]*)\)/gs;
-/**
- * Every company operation a job calls that would run as a person, one line
- * each: what `isomorph check` refuses, so a scheduled Gmail send is caught
- * before it is deployed and fails there (a job has no person). The same rule
- * answers the call at run time (job-fixture.ts); this is the static half.
- */
-export async function jobIdentityProblems(root, declaration) {
-    const problems = [];
-    for (const job of await discoverJobs(root)) {
-        const source = await readFile(job.path, "utf8");
-        for (const match of source.matchAll(executeCall)) {
-            const connection = match[1];
-            const operation = /operation\s*:\s*["']([^"']+)["']/.exec(match[2])?.[1] ?? "";
-            const mode = /mode\s*:\s*["']([^"']+)["']/.exec(match[2])?.[1];
-            if (runsAsPerson(operation, declaration, connection, mode))
-                problems.push(`jobs/${job.name}.ts: ${personRefusal(operation)}`);
-        }
-    }
-    return problems;
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@isomorph.ai/cli",
-  "version": "0.10.3",
+  "version": "0.10.4",
   "description": "Isomorph development kit CLI",
   "type": "module",
   "bin": {