@pippit-dev/cli 0.0.1

package/internal/common/upload_file.go

@@ -0,0 +1,49 @@
+package common
+
+import (
+	"context"
+	"crypto/sha1"
+	"encoding/hex"
+	"time"
+)
+
+// UploadFileOptions is the stable command-facing request shape for file upload.
+type UploadFileOptions struct {
+	Path     string `json:"path"`
+	FileName string `json:"file_name"`
+	Purpose  string `json:"purpose"`
+	Mock     bool   `json:"mock"`
+}
+
+// UploadFileResult is the JSON envelope printed by `pippit-cli short-drama +upload-file`.
+type UploadFileResult struct {
+	Scene    string            `json:"scene"`
+	FileID   string            `json:"file_id"`
+	Status   string            `json:"status"`
+	Uploaded string            `json:"uploaded_at"`
+	Request  UploadFileOptions `json:"request"`
+}
+
+func UploadFile(ctx context.Context, opts UploadFileOptions, _ *Runner) (*UploadFileResult, error) {
+	if err := ctx.Err(); err != nil {
+		return nil, err
+	}
+	key := opts.Purpose + "\x00" + opts.FileName + "\x00" + opts.Path
+	id := stableID(key, 10)
+	return &UploadFileResult{
+		Scene:    "short-drama",
+		FileID:   "file_mock_" + id,
+		Status:   "uploaded",
+		Uploaded: time.Now().UTC().Format(time.RFC3339),
+		Request:  opts,
+	}, nil
+}
+
+func stableID(key string, n int) string {
+	sum := sha1.Sum([]byte(key))
+	id := hex.EncodeToString(sum[:])
+	if n > len(id) {
+		return id
+	}
+	return id[:n]
+}

package/internal/config/config.go

@@ -0,0 +1,72 @@
+package config
+
+import (
+	"os"
+	"strings"
+	"time"
+)
+
+const (
+	DefaultBaseURL              = "https://xyq.jianying.com"
+	DefaultHTTPTimeout          = 30 * time.Second
+	DefaultAuthTTL              = 30 * time.Second
+	DefaultOAuthClientKey       = "mock-cli"
+	DefaultOAuthBaseURL         = "https://passport.bytedance.com"
+	DefaultAuthStoreServiceName = "pippit-cli"
+	SubmitRunPath               = "/api/biz/v1/skill/submit_run"
+	GetThreadPath               = "/api/biz/v1/skill/get_thread"
+	UploadFilePath              = "/api/biz/v1/skill/upload_file"
+	ListThreadFilePath          = "/api/biz/v1/skill/list_thread_file"
+	EnvXYQAccessKey             = "XYQ_ACCESS_KEY"
+)
+
+// Config holds runtime settings selected by the root command and passed down
+// into lower layers.
+type Config struct {
+	BaseURL     string
+	HTTPTimeout time.Duration
+	AuthTTL     time.Duration
+	AccessKey   string
+	OAuth       *OAuth
+	Paths       *Paths
+}
+
+type OAuth struct {
+	ClientKey        string
+	BaseURL          string
+	StoreServiceName string
+	Scopes           []string
+}
+
+type Paths struct {
+	SubmitRun      string
+	GetThread      string
+	UploadFile     string
+	ListThreadFile string
+}
+
+// Load resolves the built-in runtime config.
+func Load() *Config {
+	return &Config{
+		BaseURL:     DefaultBaseURL,
+		HTTPTimeout: DefaultHTTPTimeout,
+		AuthTTL:     DefaultAuthTTL,
+		AccessKey:   strings.TrimSpace(os.Getenv(EnvXYQAccessKey)),
+		OAuth:       resolveOAuth(),
+		Paths: &Paths{
+			SubmitRun:      SubmitRunPath,
+			GetThread:      GetThreadPath,
+			UploadFile:     UploadFilePath,
+			ListThreadFile: ListThreadFilePath,
+		},
+	}
+}
+
+func resolveOAuth() *OAuth {
+	return &OAuth{
+		ClientKey:        DefaultOAuthClientKey,
+		BaseURL:          DefaultOAuthBaseURL,
+		StoreServiceName: DefaultAuthStoreServiceName,
+		Scopes:           []string{"user_info", "aigc_generate"},
+	}
+}

package/internal/config/config_test.go

@@ -0,0 +1,49 @@
+package config
+
+import "testing"
+
+func TestLoadUsesDefaultConfig(t *testing.T) {
+	t.Setenv(EnvXYQAccessKey, "")
+	cfg := Load()
+	if cfg.BaseURL != DefaultBaseURL {
+		t.Fatalf("BaseURL = %q, want %q", cfg.BaseURL, DefaultBaseURL)
+	}
+	if cfg.HTTPTimeout != DefaultHTTPTimeout {
+		t.Fatalf("HTTPTimeout = %s, want %s", cfg.HTTPTimeout, DefaultHTTPTimeout)
+	}
+	if cfg.AuthTTL != DefaultAuthTTL {
+		t.Fatalf("AuthTTL = %s, want %s", cfg.AuthTTL, DefaultAuthTTL)
+	}
+	if cfg.AccessKey != "" {
+		t.Fatalf("AccessKey = %q, want empty", cfg.AccessKey)
+	}
+	if cfg.OAuth.ClientKey != DefaultOAuthClientKey {
+		t.Fatalf("OAuth.ClientKey = %q, want %q", cfg.OAuth.ClientKey, DefaultOAuthClientKey)
+	}
+	if cfg.OAuth.StoreServiceName != DefaultAuthStoreServiceName {
+		t.Fatalf("OAuth.StoreServiceName = %q, want %q", cfg.OAuth.StoreServiceName, DefaultAuthStoreServiceName)
+	}
+	if cfg.OAuth.BaseURL != DefaultOAuthBaseURL {
+		t.Fatalf("OAuth.BaseURL = %q, want %q", cfg.OAuth.BaseURL, DefaultOAuthBaseURL)
+	}
+	wantScopes := []string{"user_info", "aigc_generate"}
+	if len(cfg.OAuth.Scopes) != len(wantScopes) {
+		t.Fatalf("OAuth.Scopes = %#v, want %#v", cfg.OAuth.Scopes, wantScopes)
+	}
+	for i := range wantScopes {
+		if cfg.OAuth.Scopes[i] != wantScopes[i] {
+			t.Fatalf("OAuth.Scopes = %#v, want %#v", cfg.OAuth.Scopes, wantScopes)
+		}
+	}
+	if cfg.Paths.SubmitRun != SubmitRunPath {
+		t.Fatalf("SubmitRun path = %q, want %q", cfg.Paths.SubmitRun, SubmitRunPath)
+	}
+}
+
+func TestLoadReadsAccessKey(t *testing.T) {
+	t.Setenv(EnvXYQAccessKey, " test-token ")
+	cfg := Load()
+	if cfg.AccessKey != "test-token" {
+		t.Fatalf("AccessKey = %q, want trimmed token", cfg.AccessKey)
+	}
+}

package/internal/short_drama/get_thread.go

@@ -0,0 +1,137 @@
+package short_drama
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/Pippit-dev/pippit-cli/internal/common"
+	"github.com/Pippit-dev/pippit-cli/internal/config"
+)
+
+// GetThreadOptions is the stable command-facing request shape for thread lookup.
+type GetThreadOptions struct {
+	ThreadID string `json:"thread_id"`
+	RunID    string `json:"run_id,omitempty"`
+	AfterSeq int    `json:"after_seq"`
+}
+
+// ThreadEntry is a compact message or artifact entry inside a thread run.
+type ThreadEntry struct {
+	ID      string `json:"id"`
+	Role    string `json:"role"`
+	Content []any  `json:"content"`
+}
+
+// GetThreadResult is the JSON envelope printed by `pippit-cli short-drama +get-thread`.
+type GetThreadResult struct {
+	Messages []*ThreadEntry `json:"messages"`
+}
+
+type getThreadResponse struct {
+	Ret    string `json:"ret"`
+	Errmsg string `json:"errmsg"`
+	Data   struct {
+		Thread struct {
+			RunList []getThreadRun `json:"run_list"`
+		} `json:"thread"`
+	} `json:"data"`
+}
+
+type getThreadRun struct {
+	State      int              `json:"state"`
+	FailReason string           `json:"fail_reason"`
+	EntryList  []getThreadEntry `json:"entry_list"`
+}
+
+type getThreadEntry struct {
+	Message  *getThreadMessage  `json:"message"`
+	Artifact *getThreadArtifact `json:"artifact"`
+}
+
+type getThreadMessage struct {
+	MessageID       string `json:"message_id"`
+	Role            string `json:"role"`
+	Content         []any  `json:"content"`
+	ClientToolCalls []any  `json:"client_tool_calls"`
+}
+
+type getThreadArtifact struct {
+	ArtifactID string `json:"artifact_id"`
+	Role       string `json:"role"`
+	Content    []any  `json:"content"`
+}
+
+func GetThread(ctx context.Context, opts *GetThreadOptions, runner *common.Runner) (*GetThreadResult, error) {
+	if runner == nil || runner.Client == nil {
+		return nil, fmt.Errorf("get_thread runner client is required")
+	}
+
+	body := map[string]any{
+		"thread_id": opts.ThreadID,
+		"after_seq": opts.AfterSeq,
+	}
+	if opts.RunID != "" {
+		body["run_id"] = opts.RunID
+	}
+
+	var resp getThreadResponse
+	if err := runner.Client.SendRequest(ctx, getThreadPath(runner), body, &resp); err != nil {
+		return nil, fmt.Errorf("get_thread request failed: %w", err)
+	}
+	if resp.Ret != "0" {
+		if resp.Errmsg == "" {
+			resp.Errmsg = "unknown error"
+		}
+		return nil, fmt.Errorf("get_thread failed: ret=%s errmsg=%s", resp.Ret, resp.Errmsg)
+	}
+	if len(resp.Data.Thread.RunList) == 0 {
+		return nil, fmt.Errorf("get_thread response missing data.thread.run_list")
+	}
+
+	run := resp.Data.Thread.RunList[0]
+	// 4: failed
+	// 5: canceled
+	if run.State == 4 {
+		if run.FailReason == "" {
+			run.FailReason = "unknown failure"
+		}
+		return nil, fmt.Errorf("get_thread run failed: %s", run.FailReason)
+	}
+	if run.State == 5 {
+		return nil, fmt.Errorf("get_thread run canceled")
+	}
+
+	return &GetThreadResult{
+		Messages: extractThreadEntries(run),
+	}, nil
+}
+
+func extractThreadEntries(run getThreadRun) []*ThreadEntry {
+	entries := make([]*ThreadEntry, 0, len(run.EntryList))
+	for _, entry := range run.EntryList {
+		if entry.Message != nil {
+			content := append([]any(nil), entry.Message.Content...)
+			content = append(content, entry.Message.ClientToolCalls...)
+			entries = append(entries, &ThreadEntry{
+				ID:      entry.Message.MessageID,
+				Role:    entry.Message.Role,
+				Content: content,
+			})
+		}
+		if entry.Artifact != nil {
+			entries = append(entries, &ThreadEntry{
+				ID:      entry.Artifact.ArtifactID,
+				Role:    entry.Artifact.Role,
+				Content: entry.Artifact.Content,
+			})
+		}
+	}
+	return entries
+}
+
+func getThreadPath(runner *common.Runner) string {
+	if runner != nil && runner.Config != nil && runner.Config.Paths != nil && runner.Config.Paths.GetThread != "" {
+		return runner.Config.Paths.GetThread
+	}
+	return config.GetThreadPath
+}

package/internal/short_drama/mock.go

@@ -0,0 +1,47 @@
+package short_drama
+
+import (
+	"context"
+	"crypto/sha1"
+	"encoding/hex"
+)
+
+// MockClient returns deterministic IDs so the demo chain is easy to test.
+type MockClient struct{}
+
+func (MockClient) SubmitRun(ctx context.Context, opts SubmitRunOptions) (*SubmitRunResult, error) {
+	if err := ctx.Err(); err != nil {
+		return nil, err
+	}
+	key := opts.ThreadID + "\x00" + opts.Message
+	id := stableIDMock(key, 12)
+	return &SubmitRunResult{
+		ThreadID:      "thread_mock_" + id[:6],
+		RunID:         "run_mock_" + id[6:],
+		WebThreadLink: "https://xyq.jianying.com/mock/thread_mock_" + id[:6],
+	}, nil
+}
+
+func (MockClient) GetThread(ctx context.Context, opts GetThreadOptions) (*GetThreadResult, error) {
+	if err := ctx.Err(); err != nil {
+		return nil, err
+	}
+	return &GetThreadResult{
+		Messages: []*ThreadEntry{
+			{
+				ID:      "message_mock_" + stableIDMock(opts.ThreadID, 8),
+				Role:    "assistant",
+				Content: []any{"mock thread message"},
+			},
+		},
+	}, nil
+}
+
+func stableIDMock(key string, n int) string {
+	sum := sha1.Sum([]byte(key))
+	id := hex.EncodeToString(sum[:])
+	if n > len(id) {
+		return id
+	}
+	return id[:n]
+}

package/internal/short_drama/submit_run.go

@@ -0,0 +1,81 @@
+package short_drama
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/Pippit-dev/pippit-cli/internal/common"
+	"github.com/Pippit-dev/pippit-cli/internal/config"
+)
+
+// SubmitRunOptions is the stable command-facing request shape for short drama run submission.
+type SubmitRunOptions struct {
+	Message  string   `json:"message"`
+	ThreadID string   `json:"thread_id,omitempty"`
+	AssetIDs []string `json:"asset_ids,omitempty"`
+}
+
+// SubmitRunResult is the JSON envelope printed by `pippit-cli short-drama +submit-run`.
+type SubmitRunResult struct {
+	ThreadID      string `json:"thread_id"`
+	RunID         string `json:"run_id"`
+	WebThreadLink string `json:"web_thread_link"`
+}
+
+type submitRunResponse struct {
+	Ret    string `json:"ret"`
+	Errmsg string `json:"errmsg"`
+	Data   struct {
+		WebThreadLink string `json:"web_thread_link"`
+		Run           struct {
+			ThreadID string `json:"thread_id"`
+			RunID    string `json:"run_id"`
+		} `json:"run"`
+	} `json:"data"`
+}
+
+func SubmitRun(ctx context.Context, opts *SubmitRunOptions, runner *common.Runner) (*SubmitRunResult, error) {
+	if runner == nil || runner.Client == nil {
+		return nil, fmt.Errorf("submit_run runner client is required")
+	}
+
+	body := map[string]any{
+		"message": opts.Message,
+	}
+	if opts.ThreadID != "" {
+		body["thread_id"] = opts.ThreadID
+	}
+	if len(opts.AssetIDs) > 0 {
+		body["asset_ids"] = opts.AssetIDs
+	}
+	body["agent_name"] = "pippit_nest_novel_agent"
+
+	var resp submitRunResponse
+	if err := runner.Client.SendRequest(ctx, submitRunPath(runner), body, &resp); err != nil {
+		return nil, fmt.Errorf("submit_run request failed: %w", err)
+	}
+	if resp.Ret != "0" {
+		if resp.Errmsg == "" {
+			resp.Errmsg = "unknown error"
+		}
+		return nil, fmt.Errorf("submit_run failed: ret=%s errmsg=%s", resp.Ret, resp.Errmsg)
+	}
+	if resp.Data.Run.ThreadID == "" {
+		return nil, fmt.Errorf("submit_run response missing data.run.thread_id")
+	}
+	if resp.Data.Run.RunID == "" {
+		return nil, fmt.Errorf("submit_run response missing data.run.run_id")
+	}
+	return &SubmitRunResult{
+		ThreadID:      resp.Data.Run.ThreadID,
+		RunID:         resp.Data.Run.RunID,
+		WebThreadLink: resp.Data.WebThreadLink,
+	}, nil
+}
+
+func submitRunPath(runner *common.Runner) string {
+	if runner != nil && runner.Config != nil && runner.Config.Paths != nil && runner.Config.Paths.SubmitRun != "" {
+		return runner.Config.Paths.SubmitRun
+	}
+	return config.SubmitRunPath
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@pippit-dev/cli",
+  "version": "0.0.1",
+  "description": "Pippit CLI",
+  "bin": {
+    "pippit-cli": "scripts/run.js"
+  },
+  "scripts": {
+    "postinstall": "node scripts/install.js",
+    "test": "go test ./... && go vet ./..."
+  },
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ],
+  "engines": {
+    "node": ">=16"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Pippit-dev/cli.git"
+  },
+  "license": "MIT",
+  "files": [
+    "cmd",
+    "internal",
+    "skills",
+    "scripts/install.js",
+    "scripts/install-wizard.js",
+    "scripts/platform.js",
+    "scripts/run.js",
+    "scripts/skills.js",
+    "checksums.txt",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/scripts/install-wizard.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const path = require("path");
+const { isWindows, run, runSilent } = require("./platform");
+const { DEFAULT_PKG, installGlobalPackageSkills } = require("./skills");
+
+const PKG = process.env.PIPPIT_CLI_INSTALL_PACKAGE || DEFAULT_PKG;
+
+function getGloballyInstalledVersion() {
+  try {
+    const out = runSilent("npm", ["list", "-g", DEFAULT_PKG], { timeout: 15000 });
+    const match = out.toString().match(/@(\d+\.\d+\.\d+[^\s]*)/);
+    return match ? match[1] : "unknown";
+  } catch (_) {
+    return null;
+  }
+}
+
+function whichPippitCli() {
+  try {
+    const prefix = runSilent("npm", ["prefix", "-g"], { timeout: 15000 }).toString().trim();
+    const bin = isWindows
+      ? path.join(prefix, "pippit-cli.cmd")
+      : path.join(prefix, "bin", "pippit-cli");
+    if (fs.existsSync(bin)) return bin;
+  } catch (_) {
+    // Fall back to PATH lookup.
+  }
+
+  try {
+    const cmd = isWindows ? "where" : "which";
+    return runSilent(cmd, ["pippit-cli"]).toString().split("\n")[0].trim();
+  } catch (_) {
+    return null;
+  }
+}
+
+function main() {
+  const installed = getGloballyInstalledVersion();
+  if (installed) {
+    console.log(`pippit-cli is already installed globally (${installed}).`);
+  } else {
+    console.log(`Installing ${PKG} globally...`);
+    run("npm", ["install", "-g", PKG], { timeout: 120000 });
+  }
+
+  console.log("Installing pippit-cli skills...");
+  try {
+    installGlobalPackageSkills(DEFAULT_PKG);
+  } catch (err) {
+    if (!installed) {
+      throw err;
+    }
+    console.log("Existing global package does not contain skills; reinstalling...");
+    run("npm", ["install", "-g", PKG], { timeout: 120000 });
+    installGlobalPackageSkills(DEFAULT_PKG);
+  }
+
+  const bin = whichPippitCli();
+  if (!bin) {
+    console.error("pippit-cli was installed, but no global command was found in npm prefix.");
+    console.error("Check that npm's global bin directory is in PATH.");
+    process.exit(1);
+  }
+
+  console.log(`pippit-cli is ready: ${bin}`);
+  console.log("Try: pippit-cli short-drama +submit-run --message \"写一个短剧开头\"");
+}
+
+main();