stageflow 0.1.0

package/dist/server/providerRoutes.js

@@ -0,0 +1,186 @@
+import { defaultContext, detectPiHome, getAuthStatus, listProviders, loginWithApiKey, logoutProvider, ProviderAuthError, } from "../agent/providerAuth.js";
+import { answerLoginSession, cancelLoginSession, getLoginSession, startOAuthLoginSession, } from "../agent/oauthSessionManager.js";
+export function providerAuthErrorBody(err) {
+    if (err instanceof ProviderAuthError) {
+        return { status: err.status, body: { error: err.message } };
+    }
+    return {
+        status: 500,
+        body: { error: "Provider auth operation failed" },
+    };
+}
+export async function handleProviderRoutes(req, res, ctx) {
+    const { cwd, readJsonBody, json } = ctx;
+    const authCtx = ctx.providerAuthContext ?? defaultContext;
+    const method = req.method ?? "GET";
+    const rawUrl = req.url ?? "/";
+    const pathname = new URL(rawUrl, "http://localhost").pathname;
+    if (method === "GET" && pathname === "/api/providers/detect") {
+        try {
+            json(res, 200, detectPiHome(cwd));
+        }
+        catch (err) {
+            const mapped = providerAuthErrorBody(err);
+            json(res, mapped.status, mapped.body);
+        }
+        return true;
+    }
+    if (method === "GET" && pathname === "/api/providers") {
+        try {
+            json(res, 200, await listProviders(cwd, authCtx));
+        }
+        catch (err) {
+            const mapped = providerAuthErrorBody(err);
+            json(res, mapped.status, mapped.body);
+        }
+        return true;
+    }
+    const providerAuthMatch = pathname.match(/^\/api\/providers\/([^/]+)\/auth$/);
+    if (method === "GET" && providerAuthMatch) {
+        const providerId = decodeURIComponent(providerAuthMatch[1] ?? "");
+        try {
+            json(res, 200, {
+                provider: await getAuthStatus(cwd, providerId, authCtx),
+            });
+        }
+        catch (err) {
+            const mapped = providerAuthErrorBody(err);
+            json(res, mapped.status, mapped.body);
+        }
+        return true;
+    }
+    const providerLoginMatch = pathname.match(/^\/api\/providers\/([^/]+)\/login$/);
+    if (method === "POST" && providerLoginMatch) {
+        const providerId = decodeURIComponent(providerLoginMatch[1] ?? "");
+        let body;
+        try {
+            body = await readJsonBody(req);
+        }
+        catch {
+            json(res, 400, { error: "Invalid JSON body" });
+            return true;
+        }
+        const record = body !== null && typeof body === "object" && !Array.isArray(body)
+            ? body
+            : {};
+        const authType = record.authType;
+        if (authType === "oauth") {
+            try {
+                const session = await startOAuthLoginSession(cwd, providerId, authCtx);
+                json(res, 200, { ok: true, session });
+            }
+            catch (err) {
+                const mapped = providerAuthErrorBody(err);
+                json(res, mapped.status, mapped.body);
+            }
+            return true;
+        }
+        if (authType !== "api_key") {
+            json(res, 400, { error: 'authType must be "api_key" or "oauth"' });
+            return true;
+        }
+        const apiKey = record.apiKey;
+        if (typeof apiKey !== "string" || apiKey.trim().length === 0) {
+            json(res, 400, { error: "apiKey is required" });
+            return true;
+        }
+        try {
+            const provider = await loginWithApiKey(cwd, providerId, apiKey, authCtx);
+            json(res, 200, { ok: true, provider });
+        }
+        catch (err) {
+            const mapped = providerAuthErrorBody(err);
+            json(res, mapped.status, mapped.body);
+        }
+        return true;
+    }
+    const providerLoginSessionMatch = pathname.match(/^\/api\/providers\/([^/]+)\/login\/([^/]+)(?:\/(answer|cancel))?$/);
+    if (providerLoginSessionMatch) {
+        const providerId = decodeURIComponent(providerLoginSessionMatch[1] ?? "");
+        const sessionId = decodeURIComponent(providerLoginSessionMatch[2] ?? "");
+        const action = providerLoginSessionMatch[3];
+        if (method === "GET" && action === undefined) {
+            const session = getLoginSession(sessionId);
+            if (!session || session.providerId !== providerId) {
+                json(res, 404, { error: "Login session not found" });
+                return true;
+            }
+            json(res, 200, { session });
+            return true;
+        }
+        if (method === "POST" && action === "answer") {
+            let body;
+            try {
+                body = await readJsonBody(req);
+            }
+            catch {
+                json(res, 400, { error: "Invalid JSON body" });
+                return true;
+            }
+            const record = body !== null && typeof body === "object" && !Array.isArray(body)
+                ? body
+                : {};
+            const value = record.value;
+            if (typeof value !== "string") {
+                json(res, 400, { error: "value is required" });
+                return true;
+            }
+            try {
+                const existing = getLoginSession(sessionId);
+                if (!existing || existing.providerId !== providerId) {
+                    json(res, 404, { error: "Login session not found" });
+                    return true;
+                }
+                const session = answerLoginSession(sessionId, value);
+                json(res, 200, { ok: true, session });
+            }
+            catch (err) {
+                const mapped = providerAuthErrorBody(err);
+                json(res, mapped.status, mapped.body);
+            }
+            return true;
+        }
+        if (method === "POST" && action === "cancel") {
+            try {
+                await readJsonBody(req);
+            }
+            catch {
+                // empty body ok
+            }
+            try {
+                const existing = getLoginSession(sessionId);
+                if (!existing || existing.providerId !== providerId) {
+                    json(res, 404, { error: "Login session not found" });
+                    return true;
+                }
+                const session = cancelLoginSession(sessionId);
+                json(res, 200, { ok: true, session });
+            }
+            catch (err) {
+                const mapped = providerAuthErrorBody(err);
+                json(res, mapped.status, mapped.body);
+            }
+            return true;
+        }
+    }
+    const providerLogoutMatch = pathname.match(/^\/api\/providers\/([^/]+)\/logout$/);
+    if (method === "POST" && providerLogoutMatch) {
+        const providerId = decodeURIComponent(providerLogoutMatch[1] ?? "");
+        try {
+            await readJsonBody(req);
+        }
+        catch {
+            // empty body ok
+        }
+        try {
+            const provider = await logoutProvider(cwd, providerId, authCtx);
+            json(res, 200, { ok: true, provider });
+        }
+        catch (err) {
+            const mapped = providerAuthErrorBody(err);
+            json(res, mapped.status, mapped.body);
+        }
+        return true;
+    }
+    return false;
+}

package/dist/tools/askOperator.d.ts

@@ -0,0 +1,185 @@
+import { Type } from "typebox";
+export declare class AskOperatorError extends Error {
+    constructor(message: string);
+}
+export declare const ASK_OPERATOR_KINDS: readonly ["free_text", "confirm", "multi_question", "artifact_backed"];
+export type AskOperatorKind = (typeof ASK_OPERATOR_KINDS)[number];
+export type SubQuestionKind = "free_text" | "confirm";
+export type FreeTextPromptParams = {
+    kind: "free_text";
+    message: string;
+    id?: string;
+};
+export type ConfirmPromptParams = {
+    kind: "confirm";
+    message: string;
+    id?: string;
+};
+export type MultiQuestionItemParams = {
+    kind: SubQuestionKind;
+    message: string;
+    id?: string;
+};
+export type MultiQuestionPromptParams = {
+    kind: "multi_question";
+    questions: MultiQuestionItemParams[];
+    id?: string;
+};
+export type ArtifactBackedPromptParams = {
+    kind: "artifact_backed";
+    message: string;
+    artifacts: string[];
+    id?: string;
+};
+export type AskOperatorParams = FreeTextPromptParams | ConfirmPromptParams | MultiQuestionPromptParams | ArtifactBackedPromptParams;
+export type MultiQuestionItem = {
+    kind: SubQuestionKind;
+    message: string;
+    id: string;
+};
+export type AskOperatorPrompt = {
+    kind: "free_text";
+    message: string;
+    id: string;
+} | {
+    kind: "confirm";
+    message: string;
+    id: string;
+} | {
+    kind: "multi_question";
+    id: string;
+    questions: MultiQuestionItem[];
+} | {
+    kind: "artifact_backed";
+    message: string;
+    artifacts: string[];
+    id: string;
+};
+export type Decision = "accept" | "reject";
+export type FreeTextAnswerPayload = {
+    kind: "free_text";
+    text: string;
+};
+export type ConfirmAnswerPayload = {
+    kind: "confirm";
+    decision: Decision;
+    text?: string;
+};
+export type FreeTextOrConfirmPayload = FreeTextAnswerPayload | ConfirmAnswerPayload;
+export type AskOperatorAnswer = {
+    promptId: string;
+    kind: "free_text";
+    text: string;
+} | {
+    promptId: string;
+    kind: "confirm";
+    decision: Decision;
+    text?: string;
+} | {
+    promptId: string;
+    kind: "artifact_backed";
+    decision: Decision;
+    text?: string;
+} | {
+    promptId: string;
+    kind: "multi_question";
+    answers: Record<string, FreeTextOrConfirmPayload>;
+};
+export declare const askOperatorParamsSchema: Type.TUnion<[Type.TObject<{
+    kind: Type.TLiteral<"free_text">;
+    message: Type.TString;
+    id: Type.TOptional<Type.TString>;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"confirm">;
+    message: Type.TString;
+    id: Type.TOptional<Type.TString>;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"multi_question">;
+    questions: Type.TArray<Type.TObject<{
+        kind: Type.TUnion<[Type.TLiteral<"free_text">, Type.TLiteral<"confirm">]>;
+        message: Type.TString;
+        id: Type.TOptional<Type.TString>;
+    }>>;
+    id: Type.TOptional<Type.TString>;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"artifact_backed">;
+    message: Type.TString;
+    artifacts: Type.TArray<Type.TString>;
+    id: Type.TOptional<Type.TString>;
+}>]>;
+export declare const askOperatorAnswerSchema: Type.TUnion<[Type.TObject<{
+    promptId: Type.TString;
+    kind: Type.TLiteral<"free_text">;
+    text: Type.TString;
+}>, Type.TObject<{
+    promptId: Type.TString;
+    kind: Type.TLiteral<"confirm">;
+    decision: Type.TUnion<[Type.TLiteral<"accept">, Type.TLiteral<"reject">]>;
+    text: Type.TOptional<Type.TString>;
+}>, Type.TObject<{
+    promptId: Type.TString;
+    kind: Type.TLiteral<"artifact_backed">;
+    decision: Type.TUnion<[Type.TLiteral<"accept">, Type.TLiteral<"reject">]>;
+    text: Type.TOptional<Type.TString>;
+}>, Type.TObject<{
+    promptId: Type.TString;
+    kind: Type.TLiteral<"multi_question">;
+    answers: Type.TRecord<"^.*$", Type.TUnion<[Type.TObject<{
+        kind: Type.TLiteral<"free_text">;
+        text: Type.TString;
+    }>, Type.TObject<{
+        kind: Type.TLiteral<"confirm">;
+        decision: Type.TUnion<[Type.TLiteral<"accept">, Type.TLiteral<"reject">]>;
+        text: Type.TOptional<Type.TString>;
+    }>]>>;
+}>]>;
+export declare function parseAskOperatorParams(value: unknown): AskOperatorParams;
+export declare function normalizePromptIds(params: AskOperatorParams): AskOperatorPrompt;
+export declare function parseAskOperatorAnswer(value: unknown): AskOperatorAnswer;
+export declare function assertAnswerMatchesPrompt(prompt: AskOperatorPrompt, answer: AskOperatorAnswer): void;
+export declare const parsePrompt: typeof parseAskOperatorParams;
+export declare const parseAnswer: typeof parseAskOperatorAnswer;
+export type AskOperatorWaitBridge = {
+    requestWait: (prompt: AskOperatorPrompt) => Promise<unknown>;
+};
+export type AskOperatorToolOptions = AskOperatorWaitBridge;
+export type AskOperatorToolDetails = {
+    prompt: AskOperatorPrompt | null;
+    answer: AskOperatorAnswer | null;
+    error: string;
+};
+export declare function createAskOperatorTool(options: AskOperatorToolOptions): {
+    name: string;
+    label: string;
+    description: string;
+    parameters: Type.TUnion<[Type.TObject<{
+        kind: Type.TLiteral<"free_text">;
+        message: Type.TString;
+        id: Type.TOptional<Type.TString>;
+    }>, Type.TObject<{
+        kind: Type.TLiteral<"confirm">;
+        message: Type.TString;
+        id: Type.TOptional<Type.TString>;
+    }>, Type.TObject<{
+        kind: Type.TLiteral<"multi_question">;
+        questions: Type.TArray<Type.TObject<{
+            kind: Type.TUnion<[Type.TLiteral<"free_text">, Type.TLiteral<"confirm">]>;
+            message: Type.TString;
+            id: Type.TOptional<Type.TString>;
+        }>>;
+        id: Type.TOptional<Type.TString>;
+    }>, Type.TObject<{
+        kind: Type.TLiteral<"artifact_backed">;
+        message: Type.TString;
+        artifacts: Type.TArray<Type.TString>;
+        id: Type.TOptional<Type.TString>;
+    }>]>;
+    execute: (_toolCallId: string, params: unknown) => Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: AskOperatorToolDetails;
+        isError?: true | undefined;
+    }>;
+};