@sitecoreai-labs/sitecoreai-cli 0.0.4 → 0.1.0

package/dist/shared/graphql.js

@@ -11,13 +11,14 @@
  * required vs optional was duplicated.
  *
  * This module owns the wire protocol; `recipe/api/graphql.ts` and
- * `serialization/sitecore-api/graphql.ts` are thin wrappers that supply
+ * `serialization/api/graphql.ts` are thin wrappers that supply
  * the per-API constants.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runSitecoreGraphQL = exports.READ_RETRYABLE_STATUSES = void 0;
 const errors_1 = require("./errors");
 const redact_1 = require("./redact");
+const validate_1 = require("./validate");
 /**
  * Default to one attempt — no retry — so existing callers (serialization,
  * deploy) keep their current "fail fast on first error" semantics. Hot
@@ -90,28 +91,43 @@ const parseJsonIfPossible = async (response) => {
 };
 const normalizeHostUrl = (host) => {
     const withScheme = host.startsWith("http://") || host.startsWith("https://") ? host : `https://${host}`;
+    // Reject http:// (and every other non-https scheme) before a Bearer token
+    // rides this URL — every Sitecore GraphQL POST inherits this scheme. A bare
+    // host got the https:// prefix above, so this only bites when an operator
+    // explicitly persisted or passed an http:// host. assertValidUrl honours the
+    // SITECOREAI_ALLOW_HTTP=1 dev-only escape hatch.
+    (0, validate_1.assertValidUrl)(withScheme, "Environment host");
     return withScheme.endsWith("/") ? withScheme.slice(0, -1) : withScheme;
 };
 const runSitecoreGraphQL = async (environment, query, variables, transport, options) => {
     if (!environment.host) {
-        throw (0, errors_1.createCliError)("Environment host is not configured.", "INPUT_INVALID", {
-            hint: "Set a CM host with 'scai init' or pass --host.",
+        throw (0, errors_1.createScaiError)("Environment host is not configured.", "INPUT_INVALID", {
+            hint: "Set a CM host with 'scai setup init' or pass --host.",
         });
     }
     const hostUrl = normalizeHostUrl(environment.host);
     const url = `${hostUrl}${transport.servicePath}`;
     const token = await transport.getAccessToken(environment);
     if (transport.requireToken && !token) {
-        throw (0, errors_1.createCliError)(`Sitecore ${transport.label} API requires an access token.`, "AUTH_REQUIRED", { hint: "Run 'scai login' to authenticate." });
+        throw (0, errors_1.createScaiError)(`Sitecore ${transport.label} API requires an access token.`, "AUTH_REQUIRED", {
+            hint: "Authenticate with 'scai setup login', then run 'scai setup env' to provision the CM automation client this API mints its token from.",
+        });
     }
     const retryCfg = {
         ...DEFAULT_RETRY,
         ...(options?.retry ?? {}),
     };
     const sendOnce = async () => {
-        const controller = options?.timeoutMs ? new AbortController() : undefined;
+        // Default to 60s if neither the caller nor SITECOREAI_REQUEST_TIMEOUT_MS
+        // sets one. Defends against slowloris / black-hole upstreams that send
+        // response headers then stall the body indefinitely. `options.timeoutMs`
+        // stays undefined when defaulting — the retry-on-abort heuristic at the
+        // outer attempt loop (~L281) still treats explicit caller timeouts as
+        // "definitive" and default-timeouts as "probably transient, safe to retry".
+        const resolvedTimeoutMs = options?.timeoutMs ?? Number(process.env.SITECOREAI_REQUEST_TIMEOUT_MS ?? 60000);
+        const controller = resolvedTimeoutMs > 0 ? new AbortController() : undefined;
         const timeout = controller
-            ? setTimeout(() => controller.abort(), Math.max(options?.timeoutMs ?? 0, 0))
+            ? setTimeout(() => controller.abort(), resolvedTimeoutMs)
             : undefined;
         try {
             const response = await fetch(url, {
@@ -139,15 +155,15 @@ const runSitecoreGraphQL = async (environment, query, variables, transport, opti
             }
             const parsed = await parseJsonIfPossible(response);
             if (!parsed || typeof parsed !== "object") {
-                throw (0, errors_1.createCliError)(`${transport.label} GraphQL response did not contain JSON data.`, "NETWORK");
+                throw (0, errors_1.createScaiError)(`${transport.label} GraphQL response did not contain JSON data.`, "NETWORK");
             }
             const result = parsed;
             if (result.errors?.length) {
                 const message = result.errors.map((error) => error.message).join("; ");
-                throw (0, errors_1.createCliError)((0, redact_1.redactSecrets)(`${transport.label} GraphQL errors: ${message}`), "NETWORK");
+                throw (0, errors_1.createScaiError)((0, redact_1.redactSecrets)(`${transport.label} GraphQL errors: ${message}`), "NETWORK");
             }
             if (!result.data) {
-                throw (0, errors_1.createCliError)(`${transport.label} GraphQL response did not contain data.`, "NETWORK");
+                throw (0, errors_1.createScaiError)(`${transport.label} GraphQL response did not contain data.`, "NETWORK");
             }
             return result.data;
         }
@@ -192,24 +208,24 @@ const runSitecoreGraphQL = async (environment, query, variables, transport, opti
             break;
         }
     }
-    // Final mapping to CliError. HttpError → NETWORK; AbortError → timeout hint;
+    // Final mapping to ScaiError. HttpError → NETWORK; AbortError → timeout hint;
     // everything else → generic NETWORK with the original message.
     if (lastError instanceof HttpError) {
-        throw (0, errors_1.createCliError)(lastError.message, "NETWORK");
+        throw (0, errors_1.createScaiError)(lastError.message, "NETWORK");
     }
     if (lastError instanceof Error && lastError.name === "AbortError") {
-        throw (0, errors_1.createCliError)(`Sitecore ${transport.label} API request timed out.`, "NETWORK", {
+        throw (0, errors_1.createScaiError)(`Sitecore ${transport.label} API request timed out.`, "NETWORK", {
             hint: "Increase settings.apiClientTimeoutInMinutes if needed.",
         });
     }
     if (lastError instanceof Error) {
         if ("code" in lastError && lastError.code) {
-            // Already a CliError-shaped object — re-throw as-is.
+            // Already a ScaiError-shaped object — re-throw as-is.
             throw lastError;
         }
-        throw (0, errors_1.createCliError)((0, redact_1.redactSecrets)(`Sitecore ${transport.label} API request failed: ${lastError.message}`), "NETWORK");
+        throw (0, errors_1.createScaiError)((0, redact_1.redactSecrets)(`Sitecore ${transport.label} API request failed: ${lastError.message}`), "NETWORK");
     }
-    throw (0, errors_1.createCliError)((0, redact_1.redactSecrets)(`Sitecore ${transport.label} API request failed: ${String(lastError)}`), "NETWORK");
+    throw (0, errors_1.createScaiError)((0, redact_1.redactSecrets)(`Sitecore ${transport.label} API request failed: ${String(lastError)}`), "NETWORK");
 };
 exports.runSitecoreGraphQL = runSitecoreGraphQL;
 class HttpError extends Error {

package/dist/shared/history.d.ts

@@ -8,5 +8,29 @@ export type HistoryEntry = {
 };
 export declare const recordHistory: (entry: HistoryEntry) => Promise<void>;
 export declare const getHistoryPath: () => string;
+/** One entry returned by {@link readHistory}. */
+export type HistoryReadEntry = {
+    /** The raw recorded line. */
+    raw: string;
+    /** Parsed entry, or `null` when the line is not valid JSON. */
+    entry: HistoryEntry | null;
+};
+/** Options for {@link readHistory}. */
+export type ReadHistoryOptions = {
+    /** Override the history log path. */
+    path?: string;
+    /** Maximum number of (most-recent) entries to return. 0 or negative = all. */
+    limit?: number;
+    /** Return newest-first instead of file order. */
+    reverse?: boolean;
+};
+/**
+ * Read recorded CLI history.
+ *
+ * A missing log file is treated as empty (nothing recorded yet), not an
+ * error — only an unexpected read failure propagates. Entries come back
+ * in file order (oldest first) unless `reverse` is set; `limit` keeps
+ * the most recent N.
+ */
+export declare const readHistory: (options?: ReadHistoryOptions) => Promise<HistoryReadEntry[]>;
 export declare const ensureHistoryFile: () => Promise<void>;
-//# sourceMappingURL=history.d.ts.map

package/dist/shared/history.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ensureHistoryFile = exports.getHistoryPath = exports.recordHistory = void 0;
+exports.ensureHistoryFile = exports.readHistory = exports.getHistoryPath = exports.recordHistory = void 0;
 const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(require("node:path"));
 const node_os_1 = __importDefault(require("node:os"));
@@ -49,6 +49,40 @@ const recordHistory = async (entry) => {
 exports.recordHistory = recordHistory;
 const getHistoryPath = () => resolveHistoryPath();
 exports.getHistoryPath = getHistoryPath;
+/**
+ * Read recorded CLI history.
+ *
+ * A missing log file is treated as empty (nothing recorded yet), not an
+ * error — only an unexpected read failure propagates. Entries come back
+ * in file order (oldest first) unless `reverse` is set; `limit` keeps
+ * the most recent N.
+ */
+const readHistory = async (options = {}) => {
+    const filePath = options.path ?? resolveHistoryPath();
+    let lines = [];
+    try {
+        const content = await promises_1.default.readFile(filePath, "utf8");
+        lines = content.split("\n").filter((line) => line.trim().length > 0);
+    }
+    catch (error) {
+        const code = error instanceof Error && "code" in error ? error.code : undefined;
+        if (code !== "ENOENT") {
+            throw error;
+        }
+    }
+    const limit = options.limit ?? 0;
+    const selected = limit > 0 ? lines.slice(-limit) : lines;
+    const ordered = options.reverse ? [...selected].reverse() : selected;
+    return ordered.map((raw) => {
+        try {
+            return { raw, entry: JSON.parse(raw) };
+        }
+        catch {
+            return { raw, entry: null };
+        }
+    });
+};
+exports.readHistory = readHistory;
 const ensureHistoryFile = async () => {
     const filePath = resolveHistoryPath();
     try {

package/dist/shared/human-only-operations.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Operations scai categorically refuses for non-human callers.
+ *
+ * Credential provisioning either runs an interactive browser flow or is
+ * gated to interactive-human callers by the workspace policy — an agent,
+ * MCP server, or CI process cannot perform them. Declared here as a
+ * single source of truth so an agent learns a step needs a human
+ * *before* attempting it, rather than discovering it through a refusal.
+ *
+ * Surfaced by the MCP `scai_overview` tool and the `access_check`
+ * preflight, and described in prose by the `scai://help/access-and-policy`
+ * resource. `shared/` is a leaf — this module is pure data, no imports.
+ */
+/** A scai operation only an interactive human, at a real terminal, can perform. */
+export interface HumanOnlyOperation {
+    /** Stable identifier. */
+    id: string;
+    /** The CLI command a human runs, in a real terminal. */
+    command: string;
+    /** Why it cannot be performed by an agent / CI / MCP caller. */
+    reason: string;
+}
+/**
+ * The complete set of human-terminal-only operations. Keep in sync with
+ * the `needs-human-terminal` remediation sites — these are the only
+ * operations that emit that `RemediationActor`.
+ */
+export declare const HUMAN_ONLY_OPERATIONS: readonly HumanOnlyOperation[];

package/dist/shared/human-only-operations.js

@@ -0,0 +1,33 @@
+"use strict";
+/**
+ * Operations scai categorically refuses for non-human callers.
+ *
+ * Credential provisioning either runs an interactive browser flow or is
+ * gated to interactive-human callers by the workspace policy — an agent,
+ * MCP server, or CI process cannot perform them. Declared here as a
+ * single source of truth so an agent learns a step needs a human
+ * *before* attempting it, rather than discovering it through a refusal.
+ *
+ * Surfaced by the MCP `scai_overview` tool and the `access_check`
+ * preflight, and described in prose by the `scai://help/access-and-policy`
+ * resource. `shared/` is a leaf — this module is pure data, no imports.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HUMAN_ONLY_OPERATIONS = void 0;
+/**
+ * The complete set of human-terminal-only operations. Keep in sync with
+ * the `needs-human-terminal` remediation sites — these are the only
+ * operations that emit that `RemediationActor`.
+ */
+exports.HUMAN_ONLY_OPERATIONS = [
+    {
+        id: "device-login",
+        command: "scai setup login -n <env>",
+        reason: "Interactive browser device-login flow — hard-fails without a TTY, and an agent's shell is not a TTY.",
+    },
+    {
+        id: "mint-automation-client",
+        command: "scai setup client create <env>",
+        reason: "The workspace policy gates credential minting to interactive-human callers; agents, CI, and MCP processes are refused as 'm2m'.",
+    },
+];

package/dist/shared/keychain.d.ts

@@ -8,8 +8,75 @@ type CmTokenBundle = {
 export declare const getDeployToken: (envName: string) => Promise<string | undefined>;
 export declare const setDeployToken: (envName: string, token: string) => Promise<boolean>;
 export declare const clearDeployToken: (envName: string) => Promise<boolean>;
+export declare const getPublishingToken: (envName: string) => Promise<string | undefined>;
+export declare const setPublishingToken: (envName: string, token: string) => Promise<boolean>;
+export declare const clearPublishingToken: (envName: string) => Promise<boolean>;
+/**
+ * The cached Content Operations Brief API token, keyed by Sitecore
+ * `organizationId`. The Brief API is org-scoped — one minted token
+ * covers every env profile in the organization — so the cache key is
+ * the org id, not an env-profile name.
+ */
+export declare const getBriefToken: (orgId: string) => Promise<string | undefined>;
+export declare const setBriefToken: (orgId: string, token: string) => Promise<boolean>;
+export declare const clearBriefToken: (orgId: string) => Promise<boolean>;
+export declare const getCampaignToken: (envName: string) => Promise<string | undefined>;
+export declare const setCampaignToken: (envName: string, token: string) => Promise<boolean>;
+export declare const clearCampaignToken: (envName: string) => Promise<boolean>;
+/**
+ * The Agentic Studio browser session for an environment, stored as a
+ * JSON-serialized `AgentsCredential` (see `src/agents/session/types.ts`).
+ * Unlike the other entries here this is not an OAuth token — Agentic
+ * Studio has no machine-credential path yet, so scai captures a browser
+ * session cookie instead. Temporary; tracked in that file.
+ */
+export declare const getAgentsCredential: (envName: string) => Promise<string | undefined>;
+export declare const setAgentsCredential: (envName: string, credential: string) => Promise<boolean>;
+export declare const clearAgentsCredential: (envName: string) => Promise<boolean>;
 export declare const getCmTokens: (envName: string) => Promise<CmTokenBundle | undefined>;
 export declare const setCmTokens: (envName: string, tokens: CmTokenBundle) => Promise<boolean>;
 export declare const clearCmTokens: (envName: string) => Promise<boolean>;
+/**
+ * The **secret** of the scai-minted env-scoped automation client for an
+ * environment. Stored under a distinct `cm-client:` prefix — separate
+ * from the `cm:` token bundle (which holds short-lived access/refresh
+ * tokens).
+ *
+ * Per `docs/credentials.md` the keychain holds only secrets: the
+ * client's non-secret metadata (`clientId`, `name`, `mintedAt`) lives in
+ * the env profile's `automationClient` block in `sitecoreai.cli.json`.
+ * `scai setup client create` writes the metadata to the config and the
+ * secret here.
+ */
+export declare const getCmClientSecret: (envName: string) => Promise<string | undefined>;
+export declare const setCmClientSecret: (envName: string, secret: string) => Promise<boolean>;
+export declare const clearCmClientSecret: (envName: string) => Promise<boolean>;
+/**
+ * The **secret** of the scai-minted **org-level** automation client,
+ * keyed by Sitecore `organizationId`. This is the organization-scoped
+ * client `scai setup client create --org` provisions (the Deploy clients
+ * API `deploy` client type); one per org, shared by every env profile in
+ * that org.
+ *
+ * Per `docs/credentials.md` the keychain holds only secrets: the
+ * client's non-secret metadata (`clientId`, `name`, `mintedAt`) lives in
+ * the `orgClients[orgId]` block in `sitecoreai.cli.json`.
+ */
+export declare const getOrgClientSecret: (orgId: string) => Promise<string | undefined>;
+export declare const setOrgClientSecret: (orgId: string, secret: string) => Promise<boolean>;
+export declare const clearOrgClientSecret: (orgId: string) => Promise<boolean>;
+/**
+ * Brand credentials are keyed by Sitecore `organizationId`, not by
+ * env profile. The AI APIs key is one-org-per-credential (Cloud Portal
+ * → Stream → Admin → AI APIs keys), so every env profile in the same
+ * org shares one credential. We store the client secret and the cached
+ * access token under separate entries to keep their lifecycles
+ * independent (token rotates ~daily; secret is long-lived).
+ */
+export declare const getBrandClientSecret: (orgId: string) => Promise<string | undefined>;
+export declare const setBrandClientSecret: (orgId: string, secret: string) => Promise<boolean>;
+export declare const clearBrandClientSecret: (orgId: string) => Promise<boolean>;
+export declare const getBrandToken: (orgId: string) => Promise<string | undefined>;
+export declare const setBrandToken: (orgId: string, token: string) => Promise<boolean>;
+export declare const clearBrandToken: (orgId: string) => Promise<boolean>;
 export {};
-//# sourceMappingURL=keychain.d.ts.map