@appfleet-cli/cli 0.1.0

package/dist/operations.d.ts

@@ -0,0 +1,8 @@
+export type OperationsCommandResult = {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+};
+export declare function runOperationsCommand(argv: string[], options?: {
+    now?: () => Date;
+}): OperationsCommandResult;

package/dist/operations.js

@@ -0,0 +1,220 @@
+import { createIncidentWorkflow, createObservabilityIntegrationContract, createProviderRepairPlan, createRunbookWorkflow, createSecretRotationPlan, createTamperEvidentAuditChain, } from "@appfleet/domain";
+export function runOperationsCommand(argv, options = {}) {
+    const now = options.now ?? (() => new Date());
+    let parsed;
+    try {
+        parsed = parseOperationsCommand(argv);
+    }
+    catch (error) {
+        return {
+            exitCode: 1,
+            stdout: "",
+            stderr: `AppFleet ops failed: ${errorMessage(error)}\n`,
+        };
+    }
+    try {
+        const requestedAt = now().toISOString();
+        const idPrefix = `ops_${parsed.action.replace(/-/g, "_")}`;
+        const id = `${idPrefix}_${requestedAt.replace(/[^0-9]/g, "")}`;
+        const result = parsed.action === "observability"
+            ? createObservabilityIntegrationContract({
+                id,
+                workspaceId: parsed.workspaceId,
+                projectId: parsed.projectId,
+                providerId: parsed.providerId,
+                requestedAt,
+            })
+            : parsed.action === "rotate-secret"
+                ? createSecretRotationPlan({
+                    id,
+                    workspaceId: parsed.workspaceId,
+                    projectId: parsed.projectId,
+                    providerId: parsed.providerId,
+                    credentialAliases: parsed.aliases,
+                    requestedAt,
+                })
+                : parsed.action === "repair-provider"
+                    ? createProviderRepairPlan({
+                        id,
+                        workspaceId: parsed.workspaceId,
+                        projectId: parsed.projectId,
+                        providerId: parsed.providerId,
+                        requestedAt,
+                    })
+                    : parsed.action === "incident"
+                        ? createIncidentWorkflow({
+                            id,
+                            workspaceId: parsed.workspaceId,
+                            projectId: parsed.projectId,
+                            providerId: parsed.providerId,
+                            severity: parsed.severity,
+                            requestedAt,
+                        })
+                        : parsed.action === "runbook"
+                            ? createRunbookWorkflow({
+                                id,
+                                workspaceId: parsed.workspaceId,
+                                projectId: parsed.projectId,
+                                runbookKind: parsed.runbookKind,
+                                requestedAt,
+                            })
+                            : createTamperEvidentAuditChain({
+                                id,
+                                workspaceId: parsed.workspaceId,
+                                projectId: parsed.projectId,
+                                auditIds: parsed.auditIds,
+                                brokenAtAuditId: parsed.brokenAtAuditId,
+                                requestedAt,
+                            });
+        return ok(parsed.outputFormat, result, formatOperation(result));
+    }
+    catch (error) {
+        return {
+            exitCode: 1,
+            stdout: "",
+            stderr: `AppFleet ops failed: ${errorMessage(error)}\n`,
+        };
+    }
+}
+function parseOperationsCommand(argv) {
+    const normalizedArgv = argv[0] === "--" ? argv.slice(1) : argv;
+    if (normalizedArgv[0] !== "ops") {
+        throw new Error("usage: ops <observability|rotate-secret|repair-provider|incident|runbook|audit-verify> [arguments]");
+    }
+    const outputFormat = hasFlag(normalizedArgv, "--json") ? "json" : "human";
+    const workspaceId = readFlag(normalizedArgv, "--workspace") ?? "workspace_local";
+    const projectId = readFlag(normalizedArgv, "--project");
+    const providerId = readProviderId(normalizedArgv);
+    const action = normalizedArgv[1];
+    if (action === "observability") {
+        return { action, workspaceId, projectId, providerId, outputFormat };
+    }
+    if (action === "rotate-secret") {
+        if (!projectId) {
+            throw new Error("rotate-secret requires --project <project-id>");
+        }
+        const aliases = readRepeatedFlag(normalizedArgv, "--alias");
+        if (aliases.length === 0) {
+            throw new Error("rotate-secret requires at least one --alias <NAME>");
+        }
+        return { action, workspaceId, projectId, providerId, aliases, outputFormat };
+    }
+    if (action === "repair-provider") {
+        if (!providerId) {
+            throw new Error("repair-provider requires --provider <provider-id>");
+        }
+        return { action, workspaceId, projectId, providerId, outputFormat };
+    }
+    if (action === "incident") {
+        return {
+            action,
+            workspaceId,
+            projectId,
+            providerId,
+            severity: parseSeverity(readFlag(normalizedArgv, "--severity")),
+            outputFormat,
+        };
+    }
+    if (action === "runbook") {
+        return {
+            action,
+            workspaceId,
+            projectId,
+            runbookKind: parseRunbookKind(readFlag(normalizedArgv, "--kind") ?? "incident_response"),
+            outputFormat,
+        };
+    }
+    if (action === "audit-verify") {
+        return {
+            action,
+            workspaceId,
+            projectId,
+            auditIds: readRepeatedFlag(normalizedArgv, "--audit-id"),
+            brokenAtAuditId: readFlag(normalizedArgv, "--broken-at"),
+            outputFormat,
+        };
+    }
+    throw new Error("usage: ops <observability|rotate-secret|repair-provider|incident|runbook|audit-verify> [arguments]");
+}
+function formatOperation(result) {
+    return `${[
+        `AppFleet ops ${result.kind}: ${result.status}`,
+        `id=${result.id}`,
+        result.summary,
+        "runbookSteps:",
+        ...result.runbookSteps.map((step) => `- ${step}`),
+        "nextActions:",
+        ...result.nextActions.map((action) => `- ${action}`),
+        "providerApiCallsMade=false",
+        "providerMutationAttempted=false",
+        "automaticSecretRotationPerformed=false",
+        "acceptsPlaintextSecrets=false",
+    ].join("\n")}\n`;
+}
+function ok(outputFormat, value, human) {
+    return {
+        exitCode: 0,
+        stdout: outputFormat === "json" ? `${JSON.stringify(value, null, 2)}\n` : human,
+        stderr: "",
+    };
+}
+function readProviderId(argv) {
+    const value = readFlag(argv, "--provider");
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === "github" ||
+        value === "vercel" ||
+        value === "netlify" ||
+        value === "supabase" ||
+        value === "cloudflare" ||
+        value === "stripe" ||
+        value === "openai" ||
+        value === "anthropic") {
+        return value;
+    }
+    throw new Error(`unknown provider "${value}"`);
+}
+function parseSeverity(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === "sev1" || value === "sev2" || value === "sev3") {
+        return value;
+    }
+    throw new Error(`unsupported incident severity "${value}"`);
+}
+function parseRunbookKind(value) {
+    if (value === "deploy" ||
+        value === "rollback" ||
+        value === "env_rotation" ||
+        value === "migration" ||
+        value === "provider_repair" ||
+        value === "incident_response") {
+        return value;
+    }
+    throw new Error(`unsupported runbook kind "${value}"`);
+}
+function readFlag(argv, flag) {
+    const index = argv.indexOf(flag);
+    if (index === -1) {
+        return undefined;
+    }
+    return argv[index + 1];
+}
+function readRepeatedFlag(argv, flag) {
+    const values = [];
+    for (let index = 0; index < argv.length; index += 1) {
+        if (argv[index] === flag && argv[index + 1]) {
+            values.push(argv[index + 1]);
+            index += 1;
+        }
+    }
+    return values;
+}
+function hasFlag(argv, flag) {
+    return argv.includes(flag);
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/project-memory.d.ts

@@ -0,0 +1,138 @@
+import { type AppEnvironmentAlias, type AppProjectMemory, type AppProviderMemory, type AppStatusCheckResult } from "@appfleet/domain";
+type ParsedProjectMemoryCommand = {
+    action: "seed-demo-fleet";
+} | {
+    action: "discover";
+    rootPath?: string;
+    appId?: string;
+    name?: string;
+    canonicalUrl?: string;
+    remember: boolean;
+    outputFormat: "human" | "json";
+} | {
+    action: "brief";
+    appId?: string;
+    outputFormat: "human" | "json";
+} | {
+    action: "status";
+    appId?: string;
+    outputFormat: "human" | "json";
+} | {
+    action: "doctor";
+    appId?: string;
+    outputFormat: "human" | "json";
+} | {
+    action: "dashboard";
+    appId?: string;
+    outputFormat: "human" | "json";
+} | {
+    action: "check";
+    appId: string;
+} | {
+    action: "sync";
+    workspaceId: string;
+    outputFormat: "human" | "json";
+} | {
+    action: "edit";
+    appId: string;
+    name?: string;
+    canonicalUrl?: string;
+    repoUrl?: string;
+    gitRemoteFingerprint?: string;
+    rememberedUrls: string[];
+    providers: AppProviderMemory[];
+    environmentAliases: AppEnvironmentAlias[];
+    notes: string[];
+    outputFormat: "human" | "json";
+} | {
+    action: "env-list";
+    appId: string;
+    outputFormat: "human" | "json";
+} | {
+    action: "env-add";
+    appId: string;
+    environment: string;
+    environmentAliases: AppEnvironmentAlias[];
+    outputFormat: "human" | "json";
+} | {
+    action: "env-remove";
+    appId: string;
+    environment: string;
+    environmentAliasNames: string[];
+    outputFormat: "human" | "json";
+} | {
+    action: "create" | "remember";
+    appId: string;
+    name: string;
+    canonicalUrl: string;
+    repoUrl?: string;
+    gitRemoteFingerprint?: string;
+    localPaths: string[];
+    rememberedUrls: string[];
+    providers: AppProviderMemory[];
+    environmentAliases: AppEnvironmentAlias[];
+    notes: string[];
+    outputFormat: "human" | "json";
+};
+export type ProjectMemoryCommandResult = {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+};
+export type ProjectMemoryCommandOptions = {
+    storePath?: string;
+    projectRoot?: string;
+    checkUrl?: (url: string) => Promise<AppStatusCheckResult>;
+    currentGitRemoteFingerprint?: string;
+    detectGitRemoteFingerprint?: () => Promise<string | undefined>;
+    now?: () => Date;
+};
+type ProjectDiscoveryReport = {
+    type: "project_discovery_report";
+    version: 1;
+    rootPath: string;
+    project: {
+        id: string;
+        name: string;
+        canonicalUrl?: string;
+        repoUrl?: string;
+        gitRemoteFingerprint?: string;
+    };
+    packageManager?: string;
+    providers: AppProviderMemory[];
+    environmentAliases: AppEnvironmentAlias[];
+    filesScanned: number;
+    skippedPaths: string[];
+    remembered: boolean;
+    productionCloudPersistenceImplemented: false;
+    trustBoundary: string[];
+    nextActions: string[];
+};
+export declare function parseProjectMemoryCommand(argv: string[]): ParsedProjectMemoryCommand;
+export declare function runProjectMemoryCommand(argv: string[], options?: ProjectMemoryCommandOptions): Promise<ProjectMemoryCommandResult>;
+export declare function readProjectMemories(storePath?: string): Promise<AppProjectMemory[]>;
+export declare function writeProjectMemories(storePath: string, memories: AppProjectMemory[]): Promise<void>;
+export declare function upsertProjectMemory(storePath: string, memory: AppProjectMemory): Promise<void>;
+export declare function upsertProjectMemories(storePath: string, memoriesToUpsert: AppProjectMemory[]): Promise<void>;
+export declare function discoverLocalProject(input: {
+    rootPath: string;
+    appId?: string;
+    name?: string;
+    canonicalUrl?: string;
+    gitRemoteFingerprint?: string;
+    remember?: boolean;
+}): Promise<ProjectDiscoveryReport>;
+export declare function resolveProjectMemory(memories: AppProjectMemory[], input: {
+    appId?: string;
+    currentGitRemoteFingerprint?: string;
+}): {
+    ok: true;
+    memory: AppProjectMemory;
+} | {
+    ok: false;
+    message: string;
+};
+export declare function detectCurrentGitRemoteFingerprint(cwd?: string): Promise<string | undefined>;
+export declare function normalizeGitRemoteFingerprint(remoteUrl: string): string | undefined;
+export declare function checkHttpStatus(url: string): Promise<AppStatusCheckResult>;
+export {};