@tinkerlandai/indiana-cli 0.0.0-stage → 0.3.9

package/dist/chunk-4MAMIKAR.js

@@ -0,0 +1,319 @@
+// src/io.ts
+import { createReadStream } from "fs";
+import { stat } from "fs/promises";
+
+// src/errors.ts
+import { ZodError } from "zod";
+
+// ../contracts/src/errors.ts
+import { z } from "zod";
+var apiErrorCodeSchema = z.enum([
+  "INVALID_PROTOCOL_VERSION",
+  "UNSUPPORTED_PROTOCOL_VERSION",
+  "PROTOCOL_RETIRED",
+  "UNAUTHENTICATED",
+  "FORBIDDEN",
+  "SCOPE_MISMATCH",
+  "INVALID_REQUEST",
+  "NOT_FOUND",
+  "CONFLICT",
+  "PAYLOAD_TOO_LARGE",
+  "RATE_LIMITED",
+  "SERVICE_UNAVAILABLE",
+  "NOT_CONFIGURED",
+  "CAPABILITY_UNAVAILABLE",
+  "INTERNAL_ERROR"
+]);
+var managementErrorCodeSchema = z.enum([
+  ...apiErrorCodeSchema.options,
+  "INVALID_SERVER_RESPONSE",
+  "RESPONSE_TOO_LARGE",
+  "AMBIGUOUS_AUTHENTICATION",
+  "BROWSER_REQUIRED",
+  "INVALID_REDIRECT_URI",
+  "AUTHORIZATION_UNAVAILABLE",
+  "UNREGISTERED_CLIENT",
+  "MANAGEMENT_OPERATION_FAILED"
+]);
+var consoleErrorCodeSchema = z.enum([
+  ...apiErrorCodeSchema.options,
+  "stale_revision"
+]);
+var errorRecoverySchema = z.enum([
+  "fix_request",
+  "authenticate",
+  "check_permissions",
+  "check_scope",
+  "resolve_conflict",
+  "reload_state",
+  "retry_same_request",
+  "configure_integration",
+  "check_availability",
+  "upgrade_sdk",
+  "recover_operation",
+  "contact_support"
+]);
+var errorReasonSchema = z.enum([
+  "CAPABILITY_NOT_ENABLED",
+  "INTEGRATION_MISSING",
+  "PROVIDER_CREDENTIAL_REJECTED",
+  "PRICE_BINDING_REQUIRED",
+  "IDEMPOTENCY_CONFLICT",
+  "RESULT_UNKNOWN",
+  "STATE_CHANGED",
+  "OPERATION_IN_PROGRESS",
+  /** The pinned published Version uses a retired format and can no longer run; publish a new Version. */
+  "FUNNEL_VERSION_RETIRED"
+]);
+var apiErrorCatalog = {
+  INVALID_PROTOCOL_VERSION: { status: 400, recovery: "fix_request" },
+  UNSUPPORTED_PROTOCOL_VERSION: { status: 400, recovery: "upgrade_sdk" },
+  PROTOCOL_RETIRED: { status: 410, recovery: "upgrade_sdk" },
+  UNAUTHENTICATED: { status: 401, recovery: "authenticate" },
+  FORBIDDEN: { status: 403, recovery: "check_permissions" },
+  SCOPE_MISMATCH: { status: 403, recovery: "check_scope" },
+  INVALID_REQUEST: { status: 400, recovery: "fix_request" },
+  NOT_FOUND: { status: 404, recovery: "fix_request" },
+  CONFLICT: { status: 409, recovery: "resolve_conflict" },
+  PAYLOAD_TOO_LARGE: { status: 413, recovery: "fix_request" },
+  RATE_LIMITED: { status: 429, recovery: "retry_same_request" },
+  SERVICE_UNAVAILABLE: { status: 503, recovery: "retry_same_request" },
+  NOT_CONFIGURED: { status: 501, recovery: "configure_integration" },
+  CAPABILITY_UNAVAILABLE: { status: 501, recovery: "check_availability" },
+  INTERNAL_ERROR: { status: 500, recovery: "recover_operation" }
+};
+function apiErrorCodeForStatus(status) {
+  if ([400, 405, 415, 422].includes(status)) return "INVALID_REQUEST";
+  if (status === 401) return "UNAUTHENTICATED";
+  if (status === 403) return "FORBIDDEN";
+  if (status === 404) return "NOT_FOUND";
+  if ([409, 412, 425].includes(status)) return "CONFLICT";
+  if (status === 413) return "PAYLOAD_TOO_LARGE";
+  if (status === 429) return "RATE_LIMITED";
+  if (status === 501) return "NOT_CONFIGURED";
+  if ([408, 502, 503, 504].includes(status)) return "SERVICE_UNAVAILABLE";
+  return "INTERNAL_ERROR";
+}
+function errorPolicy(code, status) {
+  if (code === "CONFLICT" && status === 425)
+    return { retryable: true, recovery: "retry_same_request" };
+  if (code === "CONFLICT" && status === 412)
+    return { retryable: false, recovery: "reload_state" };
+  if ([
+    "TIMEOUT",
+    "NETWORK_ERROR",
+    "HTTP_ERROR",
+    "INVALID_RESPONSE",
+    "INVALID_SERVER_RESPONSE"
+  ].includes(code))
+    return { retryable: false, recovery: "recover_operation" };
+  if (code === "NOT_IDENTIFIED" || code === "INVALID_TOKEN")
+    return { retryable: false, recovery: "authenticate" };
+  if ([
+    "INVALID_URL",
+    "INVALID_TIMEOUT",
+    "SERVER_ONLY",
+    "AMBIGUOUS_AUTHENTICATION"
+  ].includes(code))
+    return { retryable: false, recovery: "fix_request" };
+  if (code === "PROTOCOL_MISMATCH")
+    return { retryable: false, recovery: "upgrade_sdk" };
+  if (code === "IDENTITY_CHANGED")
+    return { retryable: false, recovery: "reload_state" };
+  if (code === "CAPABILITY_UNAVAILABLE")
+    return { retryable: false, recovery: "check_availability" };
+  const known = apiErrorCodeSchema.safeParse(code);
+  if (!known.success) return { retryable: false, recovery: "contact_support" };
+  return {
+    retryable: code === "RATE_LIMITED" || code === "SERVICE_UNAVAILABLE",
+    recovery: apiErrorCatalog[known.data].recovery
+  };
+}
+function errorCodeMatchesStatus(code, status) {
+  const known = apiErrorCodeSchema.safeParse(code);
+  if (known.success) {
+    if (code === "CONFLICT") return [409, 412, 425].includes(status);
+    if (code === "SERVICE_UNAVAILABLE")
+      return [408, 502, 503, 504].includes(status);
+    if (code === "INVALID_REQUEST")
+      return [400, 405, 415, 422].includes(status);
+    if (code === "NOT_CONFIGURED") return [501, 503].includes(status);
+    return apiErrorCatalog[known.data].status === status;
+  }
+  const extraStatuses = {
+    INVALID_SERVER_RESPONSE: [502],
+    RESPONSE_TOO_LARGE: [502],
+    AMBIGUOUS_AUTHENTICATION: [400],
+    BROWSER_REQUIRED: [403],
+    INVALID_REDIRECT_URI: [403],
+    AUTHORIZATION_UNAVAILABLE: [400],
+    UNREGISTERED_CLIENT: [403],
+    MANAGEMENT_OPERATION_FAILED: [400, 422, 500]
+  };
+  return Object.hasOwn(extraStatuses, code) && (extraStatuses[code]?.includes(status) ?? false);
+}
+function parseRetryAfter(value, now = Date.now()) {
+  if (value === null) return void 0;
+  const text = value.trim();
+  if (/^\d+$/.test(text)) {
+    const seconds = Number(text);
+    return Number.isSafeInteger(seconds) ? seconds : void 0;
+  }
+  if (!/^[A-Za-z]{3}, \d{2} [A-Za-z]{3} \d{4} \d{2}:\d{2}:\d{2} GMT$/.test(text))
+    return void 0;
+  const date = Date.parse(text);
+  return Number.isFinite(date) ? Math.max(0, Math.ceil((date - now) / 1e3)) : void 0;
+}
+var errorMetadataSchema = z.object({
+  retryable: z.boolean(),
+  recovery: errorRecoverySchema,
+  reason: errorReasonSchema.optional(),
+  retryAfterSeconds: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER).optional()
+});
+var errorResponseSchema = z.object({
+  requestId: z.uuid().optional(),
+  error: z.object({
+    code: z.string().regex(/^[A-Z][A-Z0-9_]{0,95}$/),
+    message: z.string(),
+    ...errorMetadataSchema.partial().shape
+  })
+});
+var managementErrorResponseSchema = z.object({
+  error: errorResponseSchema.shape.error.extend({
+    requestId: z.uuid().optional()
+  })
+});
+var consoleErrorResponseSchema = z.object({
+  error: z.string(),
+  // Console keeps area-specific editor discriminators; management normalizes them.
+  code: z.string().regex(/^[A-Za-z][A-Za-z0-9_]{0,95}$/),
+  requestId: z.uuid(),
+  ...errorMetadataSchema.shape
+});
+function errorMetadata(code, status, options = {}) {
+  const policy = errorPolicy(code, status);
+  const recovery = options.reason === "RESULT_UNKNOWN" ? "recover_operation" : options.recovery ?? policy.recovery;
+  const retryable = policy.retryable && options.retryable !== false && recovery !== "recover_operation";
+  const retryAfterSeconds = retryable ? parseRetryAfter(options.retryAfter ?? null) : void 0;
+  return {
+    ...policy,
+    retryable,
+    recovery,
+    ...retryAfterSeconds === void 0 ? {} : { retryAfterSeconds },
+    ...options.reason ? { reason: options.reason } : {}
+  };
+}
+
+// src/errors.ts
+var CliError = class extends Error {
+  constructor(code, message, exitCode = 2, details, retryable = false, metadata = {}) {
+    super(message);
+    this.code = code;
+    this.exitCode = exitCode;
+    this.details = details;
+    this.retryable = retryable;
+    this.metadata = metadata;
+  }
+  code;
+  exitCode;
+  details;
+  retryable;
+  metadata;
+};
+function cliErrorCause(error) {
+  const seen = /* @__PURE__ */ new Set();
+  for (let depth = 0; depth < 16; depth++) {
+    if (error instanceof CliError) return error;
+    if (!error || typeof error !== "object" || seen.has(error)) return;
+    seen.add(error);
+    error = error.cause;
+  }
+  return void 0;
+}
+function schemaError(error, code, message) {
+  if (error instanceof ZodError)
+    return new CliError(code, message, 2, {
+      fields: error.issues.slice(0, 50).map(({ code: code2, path, message: message2 }) => ({ code: code2, path, message: message2 })),
+      truncated: error.issues.length > 50
+    });
+  return error;
+}
+function errorResult(error) {
+  const safe = error instanceof CliError ? error : new CliError(
+    "INTERNAL_ERROR",
+    "The command failed. No credentials or document contents have been logged.",
+    6
+  );
+  return {
+    exitCode: safe.exitCode,
+    body: {
+      error: {
+        code: safe.code,
+        message: safe.message,
+        retryable: safe.retryable,
+        recovery: safe.metadata.recovery ?? errorPolicy(safe.code, safe.metadata.status).recovery,
+        ...safe.metadata.reason ? { reason: safe.metadata.reason } : {},
+        ...safe.metadata.requestId ? { requestId: safe.metadata.requestId } : {},
+        ...safe.metadata.status === void 0 ? {} : { status: safe.metadata.status },
+        ...safe.retryable && safe.metadata.retryAfterSeconds !== void 0 ? { retryAfterSeconds: safe.metadata.retryAfterSeconds } : {},
+        ...safe.details === void 0 ? {} : { details: safe.details }
+      }
+    }
+  };
+}
+
+// src/io.ts
+async function readJsonStream(source, limit) {
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of source) {
+    size += chunk.byteLength;
+    if (size > limit)
+      throw new CliError(
+        "PAYLOAD_TOO_LARGE",
+        `JSON input exceeds ${limit} bytes.`
+      );
+    chunks.push(chunk);
+  }
+  try {
+    return JSON.parse(
+      new TextDecoder("utf-8", { fatal: true }).decode(Buffer.concat(chunks))
+    );
+  } catch {
+    throw new CliError("INVALID_JSON", "Input must contain valid UTF-8 JSON.");
+  }
+}
+async function readJsonFile(path, limit, stdin = process.stdin) {
+  if (path === "-") return readJsonStream(stdin, limit);
+  try {
+    const info = await stat(path);
+    if (!info.isFile())
+      throw new CliError("INVALID_FILE", "Input must be a regular JSON file.");
+    if (info.size > limit)
+      throw new CliError(
+        "PAYLOAD_TOO_LARGE",
+        `JSON input exceeds ${limit} bytes.`
+      );
+    return await readJsonStream(createReadStream(path), limit);
+  } catch (error) {
+    if (error instanceof CliError) throw error;
+    throw new CliError(
+      "FILE_UNAVAILABLE",
+      "Cannot read the requested JSON file."
+    );
+  }
+}
+
+export {
+  managementErrorCodeSchema,
+  apiErrorCodeForStatus,
+  errorCodeMatchesStatus,
+  managementErrorResponseSchema,
+  errorMetadata,
+  CliError,
+  cliErrorCause,
+  schemaError,
+  errorResult,
+  readJsonStream,
+  readJsonFile
+};

package/dist/io-OZLYPXWR.js

@@ -0,0 +1,8 @@
+import {
+  readJsonFile,
+  readJsonStream
+} from "./chunk-4MAMIKAR.js";
+export {
+  readJsonFile,
+  readJsonStream
+};